NL3D::CPatch Class Reference

#include <patch.h>

---

Detailed Description

A landscape patch. QuadPatch layout (same notations as 3ds Max SDK).

A---> ad ---- da <---D | | | | v v ab ia id dc

| | | |

ba ib ic cd ^ ^ | | | | B---> bc ---- cb <---C

NB: Patch 1x1 or 1xX are illegal: lot of problem: rectangular geomoprh, Son0 and Son1 must be setup as tile at beginning ...

NB: Edges number are:

• 0: AB.
• 1: BC.
• 2: CD.
• 3: DA.

Author:

Lionel Berenguier

Nevrax France

Date:

2000

Definition at line 302 of file patch.h.

Lumels methods
void	copyTileFlagsFromPatch (const CPatch *src)
void	packShadowMap (const uint8 *pLumel)
void	resetCompressedLumels ()
void	setupColorsFromTileFlags (const NLMISC::CRGBA colors[4])
	debug coloring
void	unpackShadowMap (uint8 *pShadow)
uint	evalLumelBlock (const uint8 *original, const uint8 *unCompressed, uint width, uint height)
void	packLumelBlock (uint8 *dest, const uint8 *source, uint8 alpha0, uint8 alpha1)
void	unpackLumelBlock (uint8 *dest, const uint8 *src)
[NOHEADER]
bool	getCornerSmoothFlag (uint corner) const
void	setCornerSmoothFlag (uint corner, bool smooth)
uint8	NoiseRotation
	The orientation of the NoiseMap. 0,1,2,3. This represent a CCW rotation of the NoiseMap.
uint8	_CornerSmoothFlag
	Put here for packing with NoiseRotation.
RenderList mgt.
enum	TFarVertType { FVMasterBlock = 0, FVTessBlock, FVTessBlockEdge }
void	addRefTessBlocks ()
void	appendFaceToRenderList (CTessFace *face)
void	appendFaceToTileRenderList (CTessFace *face)
void	appendFarVertexToRenderList (CTessFarVertex *fv)
void	appendNearVertexToRenderList (CTileMaterial *tileMat, CTessNearVertex *nv)
void	appendTileMaterialToRenderList (CTileMaterial *tm)
void	clearTessBlocks ()
void	decRefTessBlocks ()
void	dirtTessBlockFaceVector (CTessBlock &block)
void	extendTessBlockWithEndPos (CTessFace *face)
void	getNumTessBlock (CParamCoord pc, TFarVertType &type, uint &numtb)
uint	getNumTessBlock (CTessFace *face)
void	removeFaceFromRenderList (CTessFace *face)
void	removeFaceFromTileRenderList (CTessFace *face)
void	removeFarVertexFromRenderList (CTessFarVertex *fv)
void	removeNearVertexFromRenderList (CTileMaterial *tileMat, CTessNearVertex *nv)
void	removeTileMaterialFromRenderList (CTileMaterial *tm)
void	resetMasterBlock ()
Dynamic Lighting Management
void	addRefDLMContext ()
	Add a ref count to the DLMContext, creating it if necessary.
void	decRefDLMContext (uint count=1)
	Dec a ref count to the DLMContext, deleting it if refCount== 0.
CPatchDLMContext *	_DLMContext
sint	_DLMContextRefCount
[NOHEADER]
CTessFace *	linkTessFaceWithEdge (const NLMISC::CVector2f &uv0, const NLMISC::CVector2f &uv1, CTessFace *linkTo)
CZone *	_BindZoneNeighbor [4]
	The 4 neighbors zone of this patch (setuped at bind() time). NB: NULL if zone not loaded, or if no patch near us.
Public Member Functions
void	averageTesselationVertices ()
void	bind (CBindInfo Edges[4], bool rebind)
CAABBox	buildBBox () const
	Build the bbox of the patch, according to ctrl points, and displacement map max value.
void	compile (CZone *z, uint patchId, uint8 orderS, uint8 orderT, CTessVertex *baseVertices[4], float errorSize=0)
CVector	computeContinousVertex (float s, float t) const
CVector	computeVertex (float s, float t) const
	CPatch ()
	Constructor.
void	deleteTileUvs ()
void	forceMergeAtTileLevel ()
	For changing TileMaxSubdivision. force tesselation to be under tile.
void	getBindNeighbor (uint edge, CBindInfo &neighborEdge) const
	return neighborhood information.
const CTessVertex *	getCornerVertex (uint corner)
float	getErrorSize () const
sint	getFar0 () const
sint	getFar1 () const
CLandscape *	getLandscape () const
	Get the landscape in which is placed this patch.
uint8	getOrderForEdge (sint8 edge) const
uint8	getOrderS () const
uint8	getOrderT () const
uint16	getPatchId () const
uint	getTileMaterialRefCount () const
	Get number of TileMaterial created in this Patch.
CZone *	getZone () const
bool	isRenderClipped () const
void	recreateTileUvs ()
void	refineAll ()
	Refine this patch. Even if clipped. Refine all nodes.
void	refreshTesselationGeometry ()
void	release ()
	Un-compile a patch. Tesselation is deleted. if patch is not compiled, no - op.
void	resetRenderFar ()
void	serial (NLMISC::IStream &f)
void	unbind ()
void	unpack (CBezierPatch &p) const
CBezierPatch *	unpackIntoCache () const
	~CPatch ()
	dtor
Subdivision / ForCollision.
void	addPatchBlocksInBBox (CPatchIdent paId, const CAABBox &bbox, std::vector< CPatchBlockIdent > &paBlockIds) const
void	addTrianglesInBBox (CPatchIdent paId, const CAABBox &bbox, std::vector< CTrianglePatch > &triangles, uint8 tileTessLevel) const
void	appendTessellationLeaves (std::vector< const CTessFace * > &leaves) const
void	fillPatchQuadBlock (CPatchQuadBlock &quadBlock) const
CVector	getTesselatedPos (CUV uv) const
VB Allocator mgt.
void	allocateVBAndFaceVector ()
void	allocateVBAndFaceVectorFar1Only ()
void	debugAllocationMarkIndices (uint marker)
void	deleteVBAndFaceVector ()
void	deleteVBAndFaceVectorFar1Only ()
void	fillFar0DLMUvOnlyVertexListVB (CTessList< CTessFarVertex > &vertList)
void	fillFar1DLMUvOnlyVertexListVB (CTessList< CTessFarVertex > &vertList)
void	fillVB ()
void	fillVBFar0Only ()
void	fillVBFar1Only ()
void	fillVBFarsDLMUvOnly ()
void	fillVBIfVisible ()
void	recreateTessBlockFaceVector (CTessBlock &block)
Lightmap get interface.
void	appendTileLightInfluences (const CUV &uv, std::vector< CPointLightInfluence > &pointLightList) const
void	computeCurrentTLILightmapDiv2 (NLMISC::CRGBA *array) const
uint8	getLumel (const CUV &uv) const
	Get the lumel under the position.
Dynamic Lighting Management
void	beginDLMLighting ()
void	endDLMLighting ()
void	processDLMLight (CPatchDLMPointLight &pl)
Render
void	computeSoftwareGeomorphAndAlpha ()
CPatch *	getNextFar0ToRdr () const
CPatch *	getNextFar1ToRdr () const
void	preRender (const NLMISC::CBSphere &patchSphere)
	preRender this patch. Build Max faces / pass etc...
void	renderFar0 ()
	Render this patch, if not clipped. Call PatchCurrentDriver->renderSimpleTriangles().
void	renderFar1 ()
void	updateClipPatchVB (bool renderClipped)
void	updateTextureFarOnly (const NLMISC::CBSphere &patchSphere)
MicroVegetation
void	deleteAllVegetableIgs ()
	Delete any vegetable Ig still existing in this patch.
void	recreateAllVegetableIgs ()
	Recreate any vegetable block (as possible) in this patch. (usefull for edition).
UpdateLighting Management
CPatch *	getNextNearUL () const
	For lighting update, get Next (CiruclarList). If ==this, then list is empty.
uint	getNumNearTessBlocks () const
	get the number of Near TessBlocks. Actually OrderS/2*OrderT/2.
void	linkBeforeNearUL (CPatch *patchNext)
	For lighting update, insert this before patchNext (CiruclarList). textNext must be !NULL.
void	unlinkNearUL ()
	For lighting update, unlink (CiruclarList).
uint	updateTessBlockLighting (uint numTb)
Smooth flags methods
bool	getSmoothFlag (uint edge) const
void	setSmoothFlag (uint edge, bool flag)
Tiles get interface.
CTileElement *	getTileElement (const CUV &uv)
	Get the lumel under the position.
TileLightInfluences
void	resetTileLightInfluences ()
Data Fields
std::vector< uint8 >	CompressedLumels
CVector3s	Interiors [4]
CVector3s	Tangents [8]
std::vector< CTileColor >	TileColors
std::vector< CTileLightInfluence >	TileLightInfluences
std::vector< CTileElement >	Tiles
CVector3s	Vertices [4]
	The patch coordinates (see CBezierPatch).
Private Types
Private Member Functions
void	changeEdgeNeighbor (sint edge, CTessFace *to)
void	checkCreateVertexVBFar (CTessFarVertex *pVert)
void	checkCreateVertexVBNear (CTessNearVertex *pVert)
void	checkDeleteVertexVBFar (CTessFarVertex *pVert)
void	checkDeleteVertexVBNear (CTessNearVertex *pVert)
void	checkFillVertexVBFar (CTessFarVertex *pVert)
void	checkFillVertexVBNear (CTessNearVertex *pVert)
void	computeDefaultErrorSize ()
void	computeGeomorphAlphaFar1VertexListVB (CTessList< CTessFarVertex > &vertList)
void	computeGeomorphFar0VertexListVB (CTessList< CTessFarVertex > &vertList)
void	computeGeomorphTileVertexListVB (CTessList< CTessNearVertex > &vertList)
void	computeGeomorphVertexList (CTessList< CTessFarVertex > &vertList)
void	computeNewFar (const NLMISC::CBSphere &patchSphere, sint &newFar0, sint &newFar1)
void	computeTbTm (uint &numtb, uint &numtm, uint ts, uint tt)
void	createFaceVectorFar0OrTile ()
void	createFaceVectorFar1 ()
void	debugAllocationMarkIndicesFarList (CTessList< CTessFarVertex > &vertList, uint marker)
void	debugAllocationMarkIndicesNearList (CTessList< CTessNearVertex > &vertList, uint marker)
void	deleteFaceVectorFar0OrTile ()
void	deleteFaceVectorFar1 ()
void	fillFar0VertexListVB (CTessList< CTessFarVertex > &vertList)
void	fillFar0VertexVB (CTessFarVertex *pVert)
void	fillFar1VertexListVB (CTessList< CTessFarVertex > &vertList)
void	fillFar1VertexVB (CTessFarVertex *pVert)
void	fillTileVertexListVB (CTessList< CTessNearVertex > &vertList)
void	fillTileVertexVB (CTessNearVertex *pVert)
CTessFace *	getRootFaceForEdge (sint edge) const
CTessVertex *	getRootVertexForEdge (sint edge) const
void	makeRoots ()
void	updateFar0VBAlloc (CTessList< CTessFarVertex > &vertList, bool alloc)
void	updateFar1VBAlloc (CTessList< CTessFarVertex > &vertList, bool alloc)
void	updateTileVBAlloc (CTessList< CTessNearVertex > &vertList, bool alloc)
void	updateVBAlloc (bool alloc)
Subdivision private.
void	addPatchBlocksInBBoxRecurs (CPatchIdent paId, const CAABBox &bbox, std::vector< CPatchBlockIdent > &paBlockIds, const CBezierPatch &pa, uint8 s0, uint8 s1, uint8 t0, uint8 t1) const
void	addTileTrianglesInBBox (CPatchIdent paId, const CAABBox &bbox, std::vector< CTrianglePatch > &triangles, uint8 tessLevel, uint8 s0, uint8 t0) const
void	addTrianglesInBBoxRecurs (CPatchIdent paId, const CAABBox &bbox, std::vector< CTrianglePatch > &triangles, uint8 tessLevel, const CBezierPatch &pa, uint8 s0, uint8 s1, uint8 t0, uint8 t1) const
void	buildBBoxFromBezierPatch (const CBezierPatch &p, CAABBox &ret) const
	build a bbox from the convex hull of a bezier patch, enlarged with noise.
CVector	computeVertexButCorner (float s, float t, bool &onCorner) const
	Used by computeContinousVertex().
void	addTileLightmapEdgeWithTLI (uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse)
void	addTileLightmapPixelWithTLI (uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest)
void	addTileLightmapWithTLI (uint ts, uint tt, NLMISC::CRGBA *dest, uint stride)
void	computeNearBlockLightmap (uint ts, uint tt, NLMISC::CRGBA *lightText)
void	computeTileLightmap (uint ts, uint tt, NLMISC::CRGBA *dest, uint stride)
void	computeTileLightmapAutomatic (uint ts, uint tt, NLMISC::CRGBA *dest, uint stride)
void	computeTileLightmapEdge (uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse)
void	computeTileLightmapEdgeAutomatic (uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse)
void	computeTileLightmapEdgePrecomputed (uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse)
void	computeTileLightmapPixel (uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest)
void	computeTileLightmapPixelAroundCorner (const NLMISC::CVector2f &stIn, NLMISC::CRGBA *dest, bool lookAround)
void	computeTileLightmapPixelAutomatic (uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest)
void	computeTileLightmapPixelPrecomputed (uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest)
void	computeTileLightmapPrecomputed (uint ts, uint tt, NLMISC::CRGBA *dest, uint stride)
CRGBA	CPatch::getCurrentTLIColor (uint x, uint y) const
void	getCurrentTileTLIColors (uint ts, uint tt, NLMISC::CRGBA corners[4])
void	getTileLightMap (uint ts, uint tt, CPatchRdrPass *&rdrpass)
void	getTileLightMapUvInfo (uint ts, uint tt, CVector &uvScaleBias)
void	getTileTileColors (uint ts, uint tt, NLMISC::CRGBA corners[4])
void	modulateTileLightmapEdgeWithTileColors (uint ts, uint tt, uint edge, NLMISC::CRGBA *dest, uint stride, bool inverse)
void	modulateTileLightmapPixelWithTileColors (uint ts, uint tt, uint s, uint t, NLMISC::CRGBA *dest)
void	modulateTileLightmapWithTileColors (uint ts, uint tt, NLMISC::CRGBA *dest, uint stride)
void	releaseTileLightMap (uint ts, uint tt)
float	computeDisplaceCornerSmooth (float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
float	computeDisplaceEdgeSmooth (float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
float	computeDisplaceInteriorSmooth (float s, float t) const
float	computeDisplaceRaw (float sTile, float tTile, float s, float t) const
void	computeDisplaceRawCoordinates (float sTile, float tTile, float s, float t, sint &ts, sint &tt, sint &ms, sint &mt) const
float	computeDisplaceRawInteger (sint ts, sint tt, sint ms, sint mt) const
float	computeDisplaceRawOnNeighbor (float sTile, float tTile, float s, float t) const
void	computeNoise (float s, float t, CVector &displace) const
CVector	computeNormalCornerSmooth (float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
CVector	computeNormalEdgeSmooth (float s, float t, sint8 smoothBorderX, sint8 smoothBorderY) const
CVector	computeNormalOnNeighbor (float s, float t, uint edgeExclude) const
void	createVegetableBlock (uint numTb, uint ts, uint tt)
	Create / init the vegetableBlock in the corresponding TessBlock. TessBlocks must exist.
void	generateTileVegetable (CVegetableInstanceGroup *vegetIg, uint distType, uint ts, uint tt, CLandscapeVegetableBlockCreateContext &vbCreateCtx)
	Create / init the vegetableBlock in the corresponding TessBlock. TessBlocks must exist.
void	getTileLumelmapPixelPrecomputed (uint ts, uint tt, uint s, uint t, uint8 &dest) const
void	getTileLumelmapPrecomputed (uint ts, uint tt, uint8 *dest, uint stride)
	Create / init the vegetableBlock in the corresponding TessBlock. TessBlocks must exist.
void	releaseVegetableBlock (uint numTb)
	release the vegetableBlock in the corresponding TessBlock. TessBlocks must exist
Texture mgt.
CPatchRdrPass *	getTileRenderPass (sint tileId, sint pass)
void	getTileUvInfo (sint tileId, sint pass, bool alpha, uint8 &orient, CVector &uvScaleBias, bool &is256x256, uint8 &uvOff)
Private Attributes
CPatch *	_NextRdrFar0
CPatch *	_NextRdrFar1
CPatchRdrPass *	_PatchRdrPassFar0
CPatchRdrPass *	_PatchRdrPassFar1
CTessFarVertex	BaseFarVertices [4]
CTessVertex *	BaseVertices [4]
float	ErrorSize
bool	ExcludeFromRefineAll
sint	Far0
float	Far0UBias
float	Far0UScale
float	Far0VBias
float	Far0VScale
sint	Far1
float	Far1UBias
float	Far1UScale
float	Far1VBias
float	Far1VScale
uint8	Flags
float	OOTransitionSqrDelta
uint8	OrderS
uint8	OrderT
uint16	PatchId
CTessFace *	Son0
CTessFace *	Son1
sint	SquareLimitLevel
sint	TessBlockLimitLevel
sint	TileLimitLevel
float	TransitionSqrMin
CZone *	Zone
UpdateLighting Management
CPatch *	_ULNearNext
CPatch *	_ULNearPrec
Block renders.
CTessBlock	MasterBlock
sint	NumRenderableFaces
sint	TessBlockRefCount
NLMISC::CObjectVector< CTessBlock >	TessBlocks
Vegetables.
std::vector< CVegetableClipBlock * >	VegetableClipBlocks
	list of vegetable clipBlocks, created/destroyed at same time as TessBlocks.
Static Private Attributes
uint32	_Version = 7
CBezierPatch	CachePatch
const CPatch *	LastPatch = NULL
Friends
class	CLandscapeVegetableBlock
class	CPatchRdrPass
class	CTessFace
class	CZone

---

Member Enumeration Documentation

enum NL3D::CPatch::TFarVertType [private]

Enumeration values: FVMasterBlock  FVTessBlock  FVTessBlockEdge  Definition at line 931 of file patch.h. Referenced by appendFarVertexToRenderList(), and removeFarVertexFromRenderList(). {FVMasterBlock=0, FVTessBlock, FVTessBlockEdge};

---

Constructor & Destructor Documentation

NL3D::CPatch::CPatch (   )

Constructor. Definition at line 61 of file patch.cpp. References _BindZoneNeighbor, _CornerSmoothFlag, _DLMContext, _DLMContextRefCount, _NextRdrFar0, _NextRdrFar1, _PatchRdrPassFar0, _PatchRdrPassFar1, _ULNearNext, _ULNearPrec, ExcludeFromRefineAll, MasterBlock, NoiseRotation, NumRenderableFaces, NL3D::CTessBlock::resetClip(), Son0, Son1, and TessBlockRefCount. { Zone= NULL; OrderS=0; OrderT=0; Son0=NULL; Son1=NULL; TessBlockRefCount=0; NumRenderableFaces= 0; // for Pacs process. By default, false. ExcludeFromRefineAll= false; // Init Passes. // DO NOT FILL Patch here, because of operator= problem. do it in compile(). // By default, RdrPasses are NULL. // To force computation of texture info on next preRender(). Far0= -1; Far1= -1; // Default: not binded. _BindZoneNeighbor[0]= NULL; _BindZoneNeighbor[1]= NULL; _BindZoneNeighbor[2]= NULL; _BindZoneNeighbor[3]= NULL; NoiseRotation= 0; // No smooth by default. _CornerSmoothFlag= 0; // MasterBlock never clipped. MasterBlock.resetClip(); // Init UL circular list to NULL (not compiled) _ULNearPrec= NULL; _ULNearNext= NULL; // Dynamic LightMap _DLMContext= NULL; _DLMContextRefCount= 0; // Render Passes _PatchRdrPassFar0= NULL; _NextRdrFar0= NULL; _PatchRdrPassFar1= NULL; _NextRdrFar1= NULL; }

NL3D::CPatch::~CPatch (   )

dtor Definition at line 109 of file patch.cpp. References release(). { release(); }

---

Member Function Documentation

void NL3D::CPatch::addPatchBlocksInBBox (  CPatchIdent  paId, const CAABBox &  bbox, std::vector< CPatchBlockIdent > &  paBlockIds )  const

Add CPatchBlockIdent to CPatchBlockIdent array which intersect the bbox. NB: this method use a convex hull subdivion to search in O(logn) what part of the patch to insert. Parameters: patchId  the id of this patch, used to fill PatchBlockIdent. bbox  the bbox to test against. paBlockIds  array to be filled (no clear performed, elements added). Definition at line 504 of file patch.cpp. References addPatchBlocksInBBoxRecurs(), and unpackIntoCache(). Referenced by NL3D::CLandscape::addPatchBlocksInBBox(). { CBezierPatch &bpatch= *unpackIntoCache(); // call with the whole root patch. addPatchBlocksInBBoxRecurs(paId, bbox, paBlockIds, bpatch, 0, OrderS, 0, OrderT); }

void NL3D::CPatch::addPatchBlocksInBBoxRecurs (  CPatchIdent  paId, const CAABBox &  bbox, std::vector< CPatchBlockIdent > &  paBlockIds, const CBezierPatch &  pa, uint8  s0, uint8  s1, uint8  t0, uint8  t1 )  const [private]

recurse method of addPatchBlocksInBBox. Definition at line 514 of file patch.cpp. References buildBBoxFromBezierPatch(), NLMISC::CAABBox::intersect(), NL_PATCH_BLOCK_MAX_QUAD, nlassert, NL3D::CPatchBlockIdent::OrderS, NL3D::CPatchBlockIdent::OrderT, NL3D::CPatchBlockIdent::PatchId, NL3D::CPatchBlockIdent::S0, NL3D::CPatchBlockIdent::S1, NL3D::CBezierPatch::subdivideS(), NL3D::CBezierPatch::subdivideT(), NL3D::CPatchBlockIdent::T0, NL3D::CPatchBlockIdent::T1, uint, and uint8. Referenced by addPatchBlocksInBBox(). { uint8 lenS=s1-s0, lenT=t1-t0; nlassert(lenS>0); nlassert(lenT>0); // compute and compare bbox of the subdivision patch against request bbox. //======================== // NB: this compute includes possible noise. CAABBox paBBox; buildBBoxFromBezierPatch(pa, paBBox); // if do not intersect, stop here. if( !paBBox.intersect(bbox) ) return; // else if at CPatchQuadBlock tile level, then just add this Id. //======================== else if( lenS<=NL_PATCH_BLOCK_MAX_QUAD && lenT<=NL_PATCH_BLOCK_MAX_QUAD ) { // Add this PatchBlock desctiptor to the list. CPatchBlockIdent pbId; // Fill struct from this and result of recursion. pbId.PatchId= paId; pbId.OrderS= OrderS; pbId.OrderT= OrderT; pbId.S0= s0; pbId.S1= s1; pbId.T0= t0; pbId.T1= t1; // Add to list. paBlockIds.push_back(pbId); } // else subdiv and reccurs. //======================== else { // Subdivide along the bigger side. if(lenS>lenT) { // subdivide. CBezierPatch left, right; pa.subdivideS(left, right); uint8 sMiddle= (uint8)( ((uint)s0+(uint)s1) /2 ); // recurs left. addPatchBlocksInBBoxRecurs(paId, bbox, paBlockIds, left, s0, sMiddle, t0, t1); // recurs right. addPatchBlocksInBBoxRecurs(paId, bbox, paBlockIds, right, sMiddle, s1, t0, t1); } else { // subdivide. CBezierPatch top, bottom; pa.subdivideT(top, bottom); uint8 tMiddle= (uint8)( ((uint)t0+(uint)t1) /2 ); // recurs top. addPatchBlocksInBBoxRecurs(paId, bbox, paBlockIds, top, s0, s1, t0, tMiddle); // recurs bottom. addPatchBlocksInBBoxRecurs(paId, bbox, paBlockIds, bottom, s0, s1, tMiddle, t1); } } }

void NL3D::CPatch::addRefDLMContext (   )  [private]

Add a ref count to the DLMContext, creating it if necessary. Definition at line 1950 of file patch_lightmap.cpp. References _DLMContext, _DLMContextRefCount, fillVBFarsDLMUvOnly(), NL3D::CPatchDLMContext::generate(), getLandscape(), isRenderClipped(), and nlassert. Referenced by appendTileMaterialToRenderList(), and processDLMLight(). { // the patch must be compiled. nlassert(Zone); // if 0, create the context. if(_DLMContextRefCount==0) { nlassert(_DLMContext==NULL); _DLMContext= new CPatchDLMContext; // init now the context. _DLMContext->generate(this, getLandscape()->getTextureDLM(), getLandscape()->getPatchDLMContextList()); // If the patch is visible, it may have Far Vertices created, // hence, we must refill them with good DLM Uvs. if(!isRenderClipped()) { // setup DLM Uv with new _DLMContext fillVBFarsDLMUvOnly(); } } // incRef. _DLMContextRefCount++; }

void NL3D::CPatch::addRefTessBlocks (   )  [private]

Definition at line 611 of file patch.cpp. References NL3D::CLandscape::_VegetableManager, NL3D::CVegetableManager::createClipBlock(), getLandscape(), NL3D::CLandscape::linkPatchToNearUL(), NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK, NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT, NL3D_TESSBLOCK_TILESIZE, nlassert, NLMISC::CObjectVector< CTessBlock >::resize(), sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlockRefCount, TessBlocks, uint, and VegetableClipBlocks. Referenced by appendFaceToRenderList(), appendFarVertexToRenderList(), appendNearVertexToRenderList(), and appendTileMaterialToRenderList(). { uint i; TessBlockRefCount++; if(TessBlocks.size()==0) { // Allocate the tessblocks. //========== nlassert(NL3D_TESSBLOCK_TILESIZE==4); // A tessblock is 2*2 tiles. sint os= OrderS>>1; sint ot= OrderT>>1; nlassert(os>0); nlassert(ot>0); TessBlocks.resize(os*ot); // init all tessBlocks with the Patch ptr. for(i=0; i<TessBlocks.size(); i++) TessBlocks[i].init(this); // Vegetable management //========== CVegetableManager *vegetableManager= getLandscape()->_VegetableManager; // Create ClipBlocks. uint nTbPerCb= NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK; uint wCB= (os + nTbPerCb-1) >> NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT; uint hCB= (ot + nTbPerCb-1) >> NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT; VegetableClipBlocks.resize(wCB * hCB); // allocate ClipBlocks for(i=0; i<VegetableClipBlocks.size(); i++) { VegetableClipBlocks[i]= vegetableManager->createClipBlock(); } // updateLighting management. //========== // append patch for Near updateLighting, since TessBlock lightmap may/will exist. getLandscape()->linkPatchToNearUL(this); } }

void NL3D::CPatch::addTileLightmapEdgeWithTLI (  uint  ts, uint  tt, uint  edge, NLMISC::CRGBA *  dest, uint  stride, bool  inverse )  [private]

Definition at line 1758 of file patch_lightmap.cpp. References NL3D::bilinearColorDiv2AndAdd(), getCurrentTileTLIColors(), NL_LUMEL_BY_TILE, stride, uint, x, and y. Referenced by computeTileLightmapEdge(). { // compute colors ar corners of the tile. CRGBA corners[4]; getCurrentTileTLIColors(ts, tt, corners); // get coordinate according to edge. uint x=0,y=0; switch(edge) { case 0: x= 0; break; case 1: y= NL_LUMEL_BY_TILE-1; break; case 2: x= NL_LUMEL_BY_TILE-1; break; case 3: y= 0; break; }; // For all lumel of the edge, bilinear. uint i; for(i=0; i<NL_LUMEL_BY_TILE; i++) { // if vertical edge if( (edge&1)==0 ) y= i; // else horizontal edge else x= i; // manage inverse. uint where; if(inverse) where= (NL_LUMEL_BY_TILE-1)-i; else where= i; // compute this pixel, and modulate bilinearColorDiv2AndAdd(corners, x, y, dest[where*stride]); } }

void NL3D::CPatch::addTileLightmapPixelWithTLI (  uint  ts, uint  tt, uint  s, uint  t, NLMISC::CRGBA *  dest )  [private]

Definition at line 1793 of file patch_lightmap.cpp. References NL3D::bilinearColorDiv2AndAdd(), getCurrentTileTLIColors(), s, t, and uint. Referenced by computeTileLightmapPixel(). { // compute colors ar corners of the tile. CRGBA corners[4]; getCurrentTileTLIColors(ts, tt, corners); // compute this pixel, and modulate bilinearColorDiv2AndAdd(corners, s, t, *dest); }

void NL3D::CPatch::addTileLightmapWithTLI (  uint  ts, uint  tt, NLMISC::CRGBA *  dest, uint  stride )  [private]

Definition at line 1739 of file patch_lightmap.cpp. References NL3D::bilinearColorDiv2AndAdd(), getCurrentTileTLIColors(), NL_LUMEL_BY_TILE, stride, uint, x, and y. Referenced by computeTileLightmap(). { // compute colors ar corners of the tile. CRGBA corners[4]; getCurrentTileTLIColors(ts, tt, corners); // Bilinear accross the tile, and add to dest. uint x, y; for(y=0; y<NL_LUMEL_BY_TILE; y++) { for(x=0; x<NL_LUMEL_BY_TILE; x++) { // compute this pixel, and add bilinearColorDiv2AndAdd(corners, x, y, dest[y*stride + x]); } } }

void NL3D::CPatch::addTileTrianglesInBBox (  CPatchIdent  paId, const CAABBox &  bbox, std::vector< CTrianglePatch > &  triangles, uint8  tessLevel, uint8  s0, uint8  t0 )  const [private]

called by addTrianglesInBBoxRecurs(). effective fill the array of triangles from 1 tile at tile coordinates s0,t0. depending of tessLevel (0,1,2), 2, 8 or 32 triangles are added. (2*2m, 1*1*m or 0.5*0.5m). NB: only triangles of quad included in the bbox are added. Definition at line 335 of file patch.cpp. References computeVertex(), NLMISC::CAABBox::extend(), NLMISC::CAABBox::intersect(), nlassert, NL3D::CTrianglePatch::PatchId, NLMISC::CAABBox::setCenter(), NLMISC::CUV::U, uint, uint8, NLMISC::CTriangleUV::Uv0, NLMISC::CTriangleUV::Uv1, NLMISC::CTriangleUV::Uv2, NLMISC::CUV::V, NLMISC::CTriangle::V0, NLMISC::CTriangle::V1, and NLMISC::CTriangle::V2. Referenced by addTrianglesInBBoxRecurs(). { nlassert(s0<OrderS); nlassert(t0<OrderT); nlassert(tessLevel<=2); uint tessLen= 1<<tessLevel; // some preca. float startS0= (float)s0 / (float)(OrderS); float startT0= (float)t0 / (float)(OrderT); float ds= 1.0f/(float)(OrderS*tessLen); float dt= 1.0f/(float)(OrderT*tessLen); // Parse all quads. uint sl,tl; for(tl=0; tl<tessLen; tl++) { float fs0, fs1, ft0, ft1; // compute t patch coordinates. ft0= startT0 + (float)tl * dt ; ft1= ft0 + dt; for(sl=0; sl<tessLen; sl++) { // compute s patch coordinates. fs0= startS0 + (float)sl * ds ; fs1= fs0 + ds; // Compute Quad vectors (in CCW). CVector p0, p1, p2, p3; CUV uv0, uv1, uv2, uv3; uv0.U= fs0; uv0.V= ft0; uv1.U= fs0; uv1.V= ft1; uv2.U= fs1; uv2.V= ft1; uv3.U= fs1; uv3.V= ft0; // evaluate patch (with noise). (NB: because of cache, patch decompression cost nothing). p0= computeVertex(uv0.U, uv0.V); p1= computeVertex(uv1.U, uv1.V); p2= computeVertex(uv2.U, uv2.V); p3= computeVertex(uv3.U, uv3.V); // build the bbox of this quad, and test with request bbox. CAABBox quadBBox; quadBBox.setCenter(p0); quadBBox.extend(p1); quadBBox.extend(p2); quadBBox.extend(p3); // insert only if intersect with the bbox. if(quadBBox.intersect(bbox)) { // build triangles (in CCW). CTrianglePatch tri; tri.PatchId= paId; // first tri. tri.V0= p0; tri.V1= p1; tri.V2= p2; tri.Uv0= uv0; tri.Uv1= uv1; tri.Uv2= uv2; triangles.push_back(tri); // second tri. tri.V0= p2; tri.V1= p3; tri.V2= p0; tri.Uv0= uv2; tri.Uv1= uv3; tri.Uv2= uv0; triangles.push_back(tri); // NB: this is not the same tesselation than in tesselation.cpp. // But this looks like Ben's NLPACS::CLocalRetriever tesselation. } } } }

void NL3D::CPatch::addTrianglesInBBox (  CPatchIdent  paId, const CAABBox &  bbox, std::vector< CTrianglePatch > &  triangles, uint8  tileTessLevel )  const

Add triangles to triangles array which intersect the bbox. NB: this method use a convex hull subdivion to search in O(logn) what part of the patch to insert. Parameters: patchId  the id of this patch, used to fill triangles. bbox  the bbox to test against. triangles  array to be filled (no clear performed, elements added). tileTessLevel  0,1 or 2 size of the triangles (2*2m, 1*1m or 0.5*0.5m). Level of subdivision of a tile. Definition at line 270 of file patch.cpp. References addTrianglesInBBoxRecurs(), uint8, and unpackIntoCache(). Referenced by NL3D::CLandscape::addTrianglesInBBox(). { CBezierPatch &bpatch= *unpackIntoCache(); // call with the whole root patch. addTrianglesInBBoxRecurs(paId, bbox, triangles, tileTessLevel, bpatch, 0, OrderS, 0, OrderT); }

void NL3D::CPatch::addTrianglesInBBoxRecurs (  CPatchIdent  paId, const CAABBox &  bbox, std::vector< CTrianglePatch > &  triangles, uint8  tessLevel, const CBezierPatch &  pa, uint8  s0, uint8  s1, uint8  t0, uint8  t1 )  const [private]

recurse subdivide of the bezierPatch. 3 1st parameters are the parameter of addTrianglesInBBox(). pa is the bezier patch for this subdivision of this patch. s0, s1, t0, t1 represent the part of the bezier patch subdivided. At start, s0=0, s1=OrderS, t0=0, t1=OrderT. Definition at line 280 of file patch.cpp. References addTileTrianglesInBBox(), buildBBoxFromBezierPatch(), NLMISC::CAABBox::intersect(), nlassert, NL3D::CBezierPatch::subdivideS(), NL3D::CBezierPatch::subdivideT(), uint, and uint8. Referenced by addTrianglesInBBox(). { uint8 lenS=s1-s0, lenT=t1-t0; nlassert(lenS>0); nlassert(lenT>0); // compute and compare bbox of the subdivision patch against request bbox. //======================== // NB: this compute includes possible noise. CAABBox paBBox; buildBBoxFromBezierPatch(pa, paBBox); // if do not intersect, stop here. if( !paBBox.intersect(bbox) ) return; // else if at tile level, then just computeTriangles. //======================== else if( lenS==1 && lenT==1 ) { addTileTrianglesInBBox(paId, bbox, triangles, tessLevel, s0, t0); } // else subdiv and reccurs. //======================== else { // Subdivide along the bigger side. if(lenS>lenT) { // subdivide. CBezierPatch left, right; pa.subdivideS(left, right); uint8 sMiddle= (uint8)( ((uint)s0+(uint)s1) /2 ); // recurs left. addTrianglesInBBoxRecurs(paId, bbox, triangles, tessLevel, left, s0, sMiddle, t0, t1); // recurs right. addTrianglesInBBoxRecurs(paId, bbox, triangles, tessLevel, right, sMiddle, s1, t0, t1); } else { // subdivide. CBezierPatch top, bottom; pa.subdivideT(top, bottom); uint8 tMiddle= (uint8)( ((uint)t0+(uint)t1) /2 ); // recurs top. addTrianglesInBBoxRecurs(paId, bbox, triangles, tessLevel, top, s0, s1, t0, tMiddle); // recurs bottom. addTrianglesInBBoxRecurs(paId, bbox, triangles, tessLevel, bottom, s0, s1, tMiddle, t1); } } }

void NL3D::CPatch::allocateVBAndFaceVector (   )

Definition at line 845 of file patch_render.cpp. References createFaceVectorFar0OrTile(), createFaceVectorFar1(), and updateVBAlloc(). Referenced by preRender(), and updateClipPatchVB(). { updateVBAlloc(true); createFaceVectorFar1(); createFaceVectorFar0OrTile(); }

void NL3D::CPatch::allocateVBAndFaceVectorFar1Only (   )

Definition at line 873 of file patch_render.cpp. References createFaceVectorFar1(), NL3D::CTessBlock::FarVertexList, MasterBlock, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, updateFar1VBAlloc(), and NL3D::CTessBlock::visibleFar1(). Referenced by preRender(). { if(Far1>0) { // alloc VB. updateFar1VBAlloc(MasterBlock.FarVertexList, true); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // need update VB only if tessBlock is visible. if( tblock.visibleFar1() ) updateFar1VBAlloc(tblock.FarVertexList, true); } } createFaceVectorFar1(); }

void NL3D::CPatch::appendFaceToRenderList (  CTessFace *  face  )  [private]

Definition at line 800 of file patch.cpp. References addRefTessBlocks(), NL3D::CTessList< CTessFace >::append(), appendFaceToTileRenderList(), dirtTessBlockFaceVector(), NL3D::CTessVertex::EndPos, NL3D::CTessBlock::FaceTileMaterialRefCount, NL3D::CTessBlock::FarFaceList, getNumTessBlock(), NL3D::CTessFace::Level, MasterBlock, NumRenderableFaces, NL3D::CTessVertex::StartPos, TessBlockLimitLevel, TessBlocks, uint, NL3D::CTessFace::VBase, NL3D::CTessFace::VLeft, and NL3D::CTessFace::VRight. Referenced by NL3D::CTessFace::doMerge(), makeRoots(), NL3D::CTessFace::split(), and NL3D::CTessFace::splitRectangular(). { // Update the number of renderable Faces NumRenderableFaces++; // Update Gnal render. //==================== if(face->Level<TessBlockLimitLevel) { MasterBlock.FarFaceList.append(face); MasterBlock.FaceTileMaterialRefCount++; // The facelist is modified, so we must update the faceVector, if visible. dirtTessBlockFaceVector(MasterBlock); } else { // Alloc if necessary the TessBlocks. addRefTessBlocks(); // link the face to the good tessblock. uint numtb= getNumTessBlock(face); TessBlocks[numtb].FarFaceList.append(face); TessBlocks[numtb].FaceTileMaterialRefCount++; // The facelist is modified, so we must update the faceVector, if visible. dirtTessBlockFaceVector(TessBlocks[numtb]); // Must enlarge the BSphere of the tesblock!! // We must do it on a per-face approach, because of tessblocks 's corners which are outside of tessblocks. TessBlocks[numtb].extendSphereFirst(face->VBase->EndPos); TessBlocks[numtb].extendSphereAdd(face->VLeft->EndPos); TessBlocks[numtb].extendSphereAdd(face->VRight->EndPos); // I think this should be done too on StartPos, for geomorph (rare??...) problems. // \todo yoyo: is this necessary??? TessBlocks[numtb].extendSphereAdd(face->VBase->StartPos); TessBlocks[numtb].extendSphereAdd(face->VLeft->StartPos); TessBlocks[numtb].extendSphereAdd(face->VRight->StartPos); TessBlocks[numtb].extendSphereCompile(); // Update Tile render (no need to do it if face not at least at tessblock level). appendFaceToTileRenderList(face); } }

void NL3D::CPatch::appendFaceToTileRenderList (  CTessFace *  face  )  [private]

Definition at line 884 of file patch.cpp. References NL3D::CTessList< CTileFace >::append(), NL3D::CLandscape::appendToShadowPolyReceiver(), dirtTessBlockFaceVector(), getLandscape(), getNumTessBlock(), NL3D_MAX_TILE_FACE, nlassert, NL3D::CTileMaterial::Pass, NL3D::CRdrTileId::PatchRdrPass, sint, TessBlocks, NL3D::CTileMaterial::TileFaceList, NL3D::CTessFace::TileFaces, NL3D::CTessFace::TileMaterial, and uint. Referenced by appendFaceToRenderList(), and NL3D::CTessFace::recreateTileUvs(). { if(face->TileMaterial) { // For all valid faces, update their links. // Do not do this for lightmap, since it use same face from RGB0 pass. for(sint i=0;i<NL3D_MAX_TILE_FACE;i++) { CPatchRdrPass *tilePass= face->TileMaterial->Pass[i].PatchRdrPass; // If tile i enabled. if(tilePass) { // a face should have created for this pass. nlassert(face->TileFaces[i]); face->TileMaterial->TileFaceList[i].append(face->TileFaces[i]); } } // The facelist is modified, so we must update the faceVector, if visible. uint numtb= getNumTessBlock(face); dirtTessBlockFaceVector(TessBlocks[numtb]); // Shadow: append it to the Shadow Triangles. getLandscape()->appendToShadowPolyReceiver(face); } }

void NL3D::CPatch::appendFarVertexToRenderList (  CTessFarVertex *  fv  )  [private]

Definition at line 1040 of file patch.cpp. References addRefTessBlocks(), NL3D::CTessList< CTessFarVertex >::append(), NL3D::CTessBlock::FarVertexList, FVMasterBlock, FVTessBlockEdge, getNumTessBlock(), MasterBlock, NL3D::CTessFarVertex::OwnerBlock, NL3D::CTessFarVertex::PCoord, TessBlocks, TFarVertType, type, and uint. Referenced by makeRoots(), NL3D::CTessFace::split(), and NL3D::CTessFace::splitRectangular(). { TFarVertType type; uint numtb; getNumTessBlock(fv->PCoord, type, numtb); if(type==FVMasterBlock || type==FVTessBlockEdge) { fv->OwnerBlock= &MasterBlock; MasterBlock.FarVertexList.append(fv); } else { // Alloc if necessary the TessBlocks. addRefTessBlocks(); fv->OwnerBlock= &TessBlocks[numtb]; TessBlocks[numtb].FarVertexList.append(fv); } }

void NL3D::CPatch::appendNearVertexToRenderList (  CTileMaterial *  tileMat, CTessNearVertex *  nv )  [private]

Definition at line 1086 of file patch.cpp. References addRefTessBlocks(), computeTbTm(), nlassert, NL3D::CTessNearVertex::OwnerBlock, TessBlocks, NL3D::CTileMaterial::TileS, NL3D::CTileMaterial::TileT, and uint. Referenced by NL3D::CTessFace::allocTileUv(). { nlassert(tileMat); // Alloc if necessary the TessBlocks. addRefTessBlocks(); uint numtb, numtm; computeTbTm(numtb, numtm, tileMat->TileS, tileMat->TileT); nv->OwnerBlock= &TessBlocks[numtb]; TessBlocks[numtb].NearVertexList.append(nv); }

void NL3D::CPatch::appendTessellationLeaves (  std::vector< const CTessFace * > &  leaves  )  const

From the current tesselation of this patch, append to the list of leaves faces. Definition at line 2176 of file patch.cpp. References NL3D::CTessFace::appendTessellationLeaves(), nlassert, Son0, and Son1. Referenced by NL3D::CLandscape::getTessellationLeaves(). { nlassert(Son0); nlassert(Son1); Son0->appendTessellationLeaves(leaves); Son1->appendTessellationLeaves(leaves); }

void NL3D::CPatch::appendTileLightInfluences (  const CUV &  uv, std::vector< CPointLightInfluence > &  pointLightList )  const

Append lights under the position to pointLightList. Notice that the PointLight are ensured to be actually CPointLightNamed. Definition at line 1543 of file patch_lightmap.cpp. References NL3D::CZone::_PointLightArray, NLMISC::clamp(), NL3D::CLightInfluenceInterpolator::Corners, NL3D::CPointLightNamedArray::getPointLights(), getZone(), NL3D::CLightInfluenceInterpolator::interpolate(), NL3D::CTileLightInfluence::Light, NL3D::CLightInfluenceInterpolator::CCorner::Lights, nlassert, NLMISC::OptFastFloor(), sint, TileLightInfluences, NLMISC::CUV::U, uint, NLMISC::CUV::V, w, x, and y. Referenced by NL3D::CLandscape::appendTileLightInfluences(), and generateTileVegetable(). { /* WARNING !! only CPointLightNamed must be added here (used for convenience by CPatch::generateTileVegetable() ) */ // Compute TLI coord for BiLinear. sint x,y; // There is (OrderS/2+1) * (OrderT/2+1) tileLightInfluences (TLI). sint w= (OrderS>>1); sint h= (OrderT>>1); sint wTLI= w+1; // fastFloor: use a precision of 256 to avoid doing OptFastFloorBegin. x= NLMISC::OptFastFloor(uv.U * (w<<8)); y= NLMISC::OptFastFloor(uv.V * (h<<8)); clamp(x, 0, w<<8); clamp(y, 0, h<<8); // compute the TLI coord, and the subCoord for bilinear. sint xTLI,yTLI, xSub, ySub; xTLI= x>>8; clamp(xTLI, 0, w-1); yTLI= y>>8; clamp(yTLI, 0, h-1); // Hence, xSub and ySub range is [0, 256]. xSub= x - (xTLI<<8); ySub= y - (yTLI<<8); // Use a CLightInfluenceInterpolator to biLinear light influence CLightInfluenceInterpolator interp; // Must support only 2 light per TLI. nlassert(CTileLightInfluence::NumLightPerCorner==2); nlassert(CLightInfluenceInterpolator::NumLightPerCorner==2); // Get ref on array of PointLightNamed. CPointLightNamed *zonePointLights= NULL; if( getZone()->_PointLightArray.getPointLights().size() >0 ) { // const_cast, because will only change _IdInfluence, and // also because CLightingManager will call appendLightedModel() zonePointLights= const_cast<CPointLightNamed*>(&(getZone()->_PointLightArray.getPointLights()[0])); } // For 4 corners. for(y=0;y<2;y++) { for(x=0;x<2;x++) { // get ref on TLI, and on corner. const CTileLightInfluence &tli= TileLightInfluences[ (yTLI+y)*wTLI + xTLI+x ]; CLightInfluenceInterpolator::CCorner &corner= interp.Corners[y*2 + x]; // For all lights uint lid; for(lid= 0; lid<CTileLightInfluence::NumLightPerCorner; lid++) { // get the id of the light in the zone uint tliLightId= tli.Light[lid]; // If empty id, stop if(tliLightId==0xFF) break; else { // Set pointer of the light in the corner corner.Lights[lid]= zonePointLights + tliLightId; } } // Reset Empty slots. for(; lid<CTileLightInfluence::NumLightPerCorner; lid++) { // set to NULL corner.Lights[lid]= NULL; } } } // interpolate. interp.interpolate(pointLightList, xSub/256.f, ySub/256.f); }

void NL3D::CPatch::appendTileMaterialToRenderList (  CTileMaterial *  tm  )  [private]

Definition at line 955 of file patch.cpp. References addRefDLMContext(), addRefTessBlocks(), NL3D::CTileAddedInfo::Center, computeTbTm(), NL3D::CTileAddedInfo::Corners, createVegetableBlock(), NL3D::CBezierPatch::eval(), NL3D::CBezierPatch::evalNormal(), getLandscape(), NL3D::CLandscape::getTileCallback(), NL3D::CLandscape::isVegetableActive(), MasterBlock, nlassert, NL3D::CTileAddedInfo::Normal, TessBlocks, NL3D::ULandscapeTileCallback::tileAdded(), NL3D::CTileAddedInfo::TileID, NL3D::CTessBlock::TileMaterialRefCount, NL3D::CTileMaterial::TileS, NL3D::CTileMaterial::TileT, uint, uint64, and unpackIntoCache(). { nlassert(tm); // Alloc if necessary the TessBlocks. addRefTessBlocks(); uint numtb, numtm; computeTbTm(numtb, numtm, tm->TileS, tm->TileT); TessBlocks[numtb].RdrTileRoot[numtm]= tm; TessBlocks[numtb].FaceTileMaterialRefCount++; TessBlocks[numtb].TileMaterialRefCount++; // The master block contains the whole patch TileMaterialRefCount MasterBlock.TileMaterialRefCount++; // DynamicLighting. When in near, must compute the context, to have good UVs. //========== // inc ref to the context, creating it if needed. addRefDLMContext(); // NB: do it before creating the vegetableBlock, because vegetables use DLM Uvs. // if was no tiles before in this tessBlock, create a Vegetable block. //========== // one Tile <=> was 0 before if( TessBlocks[numtb].TileMaterialRefCount == 1 && getLandscape()->isVegetableActive() ) { createVegetableBlock(numtb, tm->TileS, tm->TileT); } ULandscapeTileCallback *tileCallback = getLandscape()->getTileCallback(); if (tileCallback) { CBezierPatch *bpatch= unpackIntoCache(); CTileAddedInfo tai; // tai.Corners[0] = bpatch->eval((float) tm->TileS / OrderS, (float) tm->TileT / OrderT); tai.Corners[1] = bpatch->eval((tm-> TileS + 1.f) / OrderS, (float) tm->TileT / OrderT); tai.Corners[2] = bpatch->eval( (tm-> TileS + 1.f) / OrderS, (tm->TileT + 1.f) / OrderT); tai.Corners[3] = bpatch->eval( (float) tm-> TileS / OrderS, (tm->TileT + 1.f) / OrderT); tai.Center = bpatch->eval( (tm-> TileS + 0.5f) / OrderS, (tm->TileT + 0.5f) / OrderT); // tai.Normal = bpatch->evalNormal( (tm-> TileS + 0.5f) / OrderS, (tm->TileT + 0.5f) / OrderT); tai.TileID = (uint64) tm; // pointer to tile material serves as a unique identifier // tileCallback->tileAdded(tai); } }

void NL3D::CPatch::averageTesselationVertices (   )

This is especially for Pacs. see CLandscape desc. Definition at line 1505 of file patch.cpp. References NL3D::CTessFace::averageTesselationVertices(), BaseVertices, computeVertex(), NL3D::CTessVertex::EndPos, nlassert, NL3D::CTessVertex::Pos, Son0, Son1, and NL3D::CTessVertex::StartPos. Referenced by NL3D::CZone::averageTesselationVertices(). { nlassert(Son0); nlassert(Son1); // Recompute the BaseVertices. This is usefull for Pacs. // Because CLandscape::averageTesselationVertices() is made on a strict order for patchs (map of zones, then // array of patchs), we are sure to overwrite BaseVertices in this order. CTessVertex *a= BaseVertices[0]; CTessVertex *b= BaseVertices[1]; CTessVertex *c= BaseVertices[2]; CTessVertex *d= BaseVertices[3]; // Set positions. a->Pos= a->StartPos= a->EndPos= computeVertex(0,0); b->Pos= b->StartPos= b->EndPos= computeVertex(0,1); c->Pos= c->StartPos= c->EndPos= computeVertex(1,1); d->Pos= d->StartPos= d->EndPos= computeVertex(1,0); // Average the tesselation of sons. Son0->averageTesselationVertices(); Son1->averageTesselationVertices(); }

void NL3D::CPatch::beginDLMLighting (   )

begin Dynamic light Process. reset texture To Black (if needed) Called by CLandscape. _DLMContext must exist Definition at line 2005 of file patch_lightmap.cpp. References _DLMContext, NL3D::CPatchDLMContext::clearLighting(), NL3D::CPatchDLMContext::CurPointLightCount, isRenderClipped(), nlassert, and NL3D::CPatchDLMContext::OldPointLightCount. Referenced by NL3D::CLandscape::computeDynamicLighting(). { nlassert(_DLMContext); // Must bkup prec pointLightCount in OldPointLightCount, and reset CurPointLightCount _DLMContext->OldPointLightCount= _DLMContext->CurPointLightCount; _DLMContext->CurPointLightCount= 0; // clear lighting, only if patch is visible if(!isRenderClipped()) // NB: no-op if src is already full black. _DLMContext->clearLighting(); }

void NL3D::CPatch::bind (  CBindInfo  Edges[4], bool  rebind )

bind the patch to 4 neighbors, given in this patch edge order (0,1,2,3). Tesselation is reseted (patch unbound first). NB: this patch and his neighborood must be compiled... NB: neighbor patchs must not be NULL (but according to NPatchs). Definition at line 1847 of file patch.cpp. References _BindZoneNeighbor, BaseVertices, bind(), NL3D::CPatchUVLocator::build(), changeEdgeNeighbor(), checkFillVertexVBFar(), NL3D::CTessFace::computeSplitPoint(), computeVertex(), NL3D::CPatch::CBindInfo::Edge, NL3D::CTessVertex::EndPos, NL3D::CTessFace::FBase, NL3D::CTessFace::FLeft, NL3D::CTessFace::FRight, NL3D::CTessFace::FVBase, NL3D::CTessFace::FVLeft, NL3D::CTessFace::FVRight, getBindNeighbor(), getRootFaceForEdge(), getRootVertexForEdge(), NL3D::CTessFace::isLeaf(), linkTessFaceWithEdge(), NL3D::CPatchUVLocator::locateUV(), NL3D::CPatch::CBindInfo::Next, nlassert, NL3D::CPatch::CBindInfo::NPatchs, OrderS, OrderT, NL3D::CTessVertex::Pos, NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint, Son0, Son1, NL3D::CTessFace::SonLeft, NL3D::CTessFace::SonRight, NL3D::CTessVertex::StartPos, uint, NL3D::CTessFace::updateBind(), NL3D::CTessFace::VBase, NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by bind(), and NL3D::CZone::bindPatch(). { // The multiple Patch Face. // By default, Patch==NULL, FLeft, FRight and FBase==NULL so ok! static CTessFace bind1_2[4]; static CTessFace bind1_4[8]; // THIS PATCH MUST BE UNBOUND FIRST!!!!! nlassert(Son0 && Son1); nlassert(Son0->isLeaf() && Son1->isLeaf()); nlassert(Son0->FLeft == NULL); nlassert(Son0->FRight == NULL); nlassert(Son1->FLeft == NULL); nlassert(Son1->FRight == NULL); // bind the Realtime bind info here (before any computeVertex, and before bind too). sint i; for(i=0;i<4;i++) { // just Copy zone (if not NULL). _BindZoneNeighbor[i]= Edges[i].Zone; } if(!rebind) { // Just recompute base vertices. CTessVertex *a= BaseVertices[0]; CTessVertex *b= BaseVertices[1]; CTessVertex *c= BaseVertices[2]; CTessVertex *d= BaseVertices[3]; // Set positions. a->Pos= a->StartPos= a->EndPos= computeVertex(0,0); b->Pos= b->StartPos= b->EndPos= computeVertex(0,1); c->Pos= c->StartPos= c->EndPos= computeVertex(1,1); d->Pos= d->StartPos= d->EndPos= computeVertex(1,0); // NB: no propagation problem, since the patch has root only (since has to be unbound!!!) // Recompute centers. Son0->computeSplitPoint(); Son1->computeSplitPoint(); } else { // Keep old Vertices as computed from neighbors, but reFill the 4 FarVertices. // NB: don't do it on NearVertices because suppose that Near is Off when a bind occurs (often far away). checkFillVertexVBFar(Son0->FVBase); checkFillVertexVBFar(Son0->FVLeft); checkFillVertexVBFar(Son0->FVRight); checkFillVertexVBFar(Son1->FVBase); } // Bind the roots. for(i=0;i<4;i++) { CBindInfo &bind= Edges[i]; nlassert(bind.NPatchs==0 || bind.NPatchs==1 || bind.NPatchs==2 || bind.NPatchs==4 || bind.NPatchs==5); if(bind.NPatchs==1) { // Bind me on Next. this->changeEdgeNeighbor(i, bind.Next[0]->getRootFaceForEdge(bind.Edge[0])); // Bind Next on me. bind.Next[0]->changeEdgeNeighbor(bind.Edge[0], this->getRootFaceForEdge(i)); } else if(bind.NPatchs==2) { // Setup multiple bind. this->changeEdgeNeighbor(i, bind1_2+i); bind1_2[i].FBase= this->getRootFaceForEdge(i); // Setup the multiple face. // Follow the conventions! Make a draw for understand. Small Patchs are numbered in CCW. bind1_2[i].SonRight= bind.Next[0]->getRootFaceForEdge(bind.Edge[0]); bind1_2[i].SonLeft= bind.Next[1]->getRootFaceForEdge(bind.Edge[1]); bind1_2[i].VBase= bind.Next[0]->getRootVertexForEdge(bind.Edge[0]); // Set a "flag" to neighbors, so they know what edge is to be bind on me. bind.Next[0]->changeEdgeNeighbor(bind.Edge[0], &CTessFace::MultipleBindFace); bind.Next[1]->changeEdgeNeighbor(bind.Edge[1], &CTessFace::MultipleBindFace); } else if(bind.NPatchs==4) { // Setup multiple bind level 0. this->changeEdgeNeighbor(i, bind1_2+i); bind1_2[i].FBase= this->getRootFaceForEdge(i); // Setup multiple bind level 1. // Follow the conventions! Make a draw for understand. Small Patchs are numbered in CCW. bind1_2[i].SonRight= bind1_4 + 2*i+0; bind1_2[i].SonLeft= bind1_4 + 2*i+1; bind1_2[i].VBase= bind.Next[1]->getRootVertexForEdge(bind.Edge[1]); // Make first multiple face bind level1. bind1_4[2*i+0].FBase= &CTessFace::MultipleBindFace; // to link correctly when the root face will be splitted. bind1_4[2*i+0].SonRight= bind.Next[0]->getRootFaceForEdge(bind.Edge[0]); bind1_4[2*i+0].SonLeft= bind.Next[1]->getRootFaceForEdge(bind.Edge[1]); bind1_4[2*i+0].VBase= bind.Next[0]->getRootVertexForEdge(bind.Edge[0]); // Make second multiple face bind level1. bind1_4[2*i+1].FBase= &CTessFace::MultipleBindFace; // to link correctly when the root face will be splitted. bind1_4[2*i+1].SonRight= bind.Next[2]->getRootFaceForEdge(bind.Edge[2]); bind1_4[2*i+1].SonLeft= bind.Next[3]->getRootFaceForEdge(bind.Edge[3]); bind1_4[2*i+1].VBase= bind.Next[2]->getRootVertexForEdge(bind.Edge[2]); // Set a "flag" to neighbors, so they know what edge is to be bind on me. bind.Next[0]->changeEdgeNeighbor(bind.Edge[0], &CTessFace::MultipleBindFace); bind.Next[1]->changeEdgeNeighbor(bind.Edge[1], &CTessFace::MultipleBindFace); bind.Next[2]->changeEdgeNeighbor(bind.Edge[2], &CTessFace::MultipleBindFace); bind.Next[3]->changeEdgeNeighbor(bind.Edge[3], &CTessFace::MultipleBindFace); } else if(bind.NPatchs==5) { /* I am binded to a bigger patch and this one has already done the binding on me => It must be correclty tesselated. Note also that bind 1/X are only possible on interior of zone. */ // First, make the link with the face to which I must connect. // ----------------- // Get the coordinate of the current edge of this patch CVector2f uvi0, uvi1; switch(i) { case 0: uvi0.set(0,0); uvi1.set(0,1); break; case 1: uvi0.set(0,1); uvi1.set(1,1); break; case 2: uvi0.set(1,1); uvi1.set(1,0); break; case 3: uvi0.set(1,0); uvi1.set(0,0); break; }; // mul by OrderS/OrderT for CPatchUVLocator uvi0.x*= OrderS; uvi0.y*= OrderT; uvi1.x*= OrderS; uvi1.y*= OrderT; // build a CPatchUVLocator to transpose coorindate ot this edge in coordinate on the bigger Neighbor patch. CBindInfo bindInfo; getBindNeighbor(i, bindInfo); nlassert(bindInfo.Zone!=NULL && bindInfo.NPatchs==1); CPatchUVLocator puvloc; puvloc.build(this, i, bindInfo); // transpose from this patch coord in neighbor patch coord. CVector2f uvo0, uvo1; uint pid; CPatch *patchNeighbor; // Do it for uvi0 pid= puvloc.selectPatch(uvi0); puvloc.locateUV(uvi0, pid, patchNeighbor, uvo0); nlassert(patchNeighbor == bindInfo.Next[0]); // Do it for uvi1 pid= puvloc.selectPatch(uvi1); puvloc.locateUV(uvi1, pid, patchNeighbor, uvo1); nlassert(patchNeighbor == bindInfo.Next[0]); // Rescale to have uv in 0,1 basis. uvo0.x/= patchNeighbor->OrderS; uvo0.y/= patchNeighbor->OrderT; uvo1.x/= patchNeighbor->OrderS; uvo1.y/= patchNeighbor->OrderT; // Now, traverse the tesselation and find the first CTessFace which use this edge. CTessFace *faceNeighbor; faceNeighbor= patchNeighbor->linkTessFaceWithEdge(uvo0, uvo1, this->getRootFaceForEdge(i)); nlassert(faceNeighbor); // Bind me on Next. this->changeEdgeNeighbor(i, faceNeighbor); } } // Propagate the binds to sons. Son0->updateBind(); Son1->updateBind(); }

CAABBox NL3D::CPatch::buildBBox (   )  const

Build the bbox of the patch, according to ctrl points, and displacement map max value. Definition at line 257 of file patch.cpp. References buildBBoxFromBezierPatch(), and unpackIntoCache(). Referenced by NL3D::CLandscape::addZone(), and NL3D::CZone::compile(). { CBezierPatch &p= *unpackIntoCache(); // Compute Bounding Box. (easiest way...) CAABBox ret; buildBBoxFromBezierPatch(p, ret); return ret; }

void NL3D::CPatch::buildBBoxFromBezierPatch (  const CBezierPatch &  p, CAABBox &  ret )  const [private]

build a bbox from the convex hull of a bezier patch, enlarged with noise. Definition at line 221 of file patch.cpp. References NL3D::CBezierPatch::Interiors, NLMISC::CVector::maxof(), NLMISC::CVector::minof(), NL3D_NOISE_MAX, NLMISC::CAABBox::setMinMax(), sint, NL3D::CBezierPatch::Tangents, and NL3D::CBezierPatch::Vertices. Referenced by addPatchBlocksInBBoxRecurs(), addTrianglesInBBoxRecurs(), and buildBBox(). { // Because of the structure of CAABBox, extend() is not fast enough for us. first compute bmin, bmax, // then compute the bbox. CVector bmin= p.Vertices[0]; CVector bmax= bmin; sint i; for(i=0;i<4;i++) { bmin.minof(bmin, p.Vertices[i]); bmax.maxof(bmax, p.Vertices[i]); } for(i=0;i<8;i++) { bmin.minof(bmin, p.Tangents[i]); bmax.maxof(bmax, p.Tangents[i]); } for(i=0;i<4;i++) { bmin.minof(bmin, p.Interiors[i]); bmax.maxof(bmax, p.Interiors[i]); } // Modulate with the maximum displacement map (usefull for patch clipping). static CVector vectorNoiseMax(NL3D_NOISE_MAX, NL3D_NOISE_MAX, NL3D_NOISE_MAX); bmin-= vectorNoiseMax; bmax+= vectorNoiseMax; // NB: this is not very optimal, since the BBox may be very too big. eg: patch 16mx16m => bbox 18mx18m. // But remind that tessblocks do not use this BBox, and are computed with the real geometry. ret.setMinMax(bmin, bmax); }

void NL3D::CPatch::changeEdgeNeighbor (  sint  edge, CTessFace *  to )  [private]

Definition at line 1805 of file patch.cpp. References NL3D::CTessFace::FLeft, NL3D::CTessFace::FRight, nlassert, sint, Son0, and Son1. Referenced by bind(). { nlassert(edge>=0 && edge<=3); // See tessellation rules. if(OrderS>=OrderT) { switch(edge) { case 0: Son0->FRight= to; break; case 1: Son0->FLeft= to; break; case 2: Son1->FRight= to; break; case 3: Son1->FLeft= to; break; } } else { switch(edge) { case 0: Son0->FLeft= to; break; case 1: Son1->FRight= to; break; case 2: Son1->FLeft= to; break; case 3: Son0->FRight= to; break; } } }

void NL3D::CPatch::checkCreateVertexVBFar (  CTessFarVertex *  pVert  )  [private]

Definition at line 1502 of file patch_render.cpp. References NL3D::CTessFarVertex::Index0, NL3D::CTessFarVertex::Index1, isRenderClipped(), nlassert, NL3D::CTessFarVertex::OwnerBlock, NL3D::CTessBlock::visibleFar0(), and NL3D::CTessBlock::visibleFar1(). Referenced by NL3D::CTessFace::split(), and NL3D::CTessFace::splitRectangular(). { nlassert(pVert); // If visible, and Far0 in !Tile Mode, allocate. // NB: must test Far0>0 because vertices are reallocated in preRender() if a change of Far occurs. if(!isRenderClipped() && Far0>0 && pVert->OwnerBlock->visibleFar0() ) { pVert->Index0= CLandscapeGlobals::CurrentFar0VBAllocator->allocateVertex(); } // Idem for Far1 if(!isRenderClipped() && Far1>0 && pVert->OwnerBlock->visibleFar1()) { pVert->Index1= CLandscapeGlobals::CurrentFar1VBAllocator->allocateVertex(); } }

void NL3D::CPatch::checkCreateVertexVBNear (  CTessNearVertex *  pVert  )  [private]

Definition at line 1543 of file patch_render.cpp. References NL3D::CTessNearVertex::Index, isRenderClipped(), nlassert, NL3D::CTessNearVertex::OwnerBlock, and NL3D::CTessBlock::visibleTile(). Referenced by NL3D::CTessFace::checkCreateFillTileVB(). { nlassert(pVert); // If visible, and Far0 in Tile Mode, allocate. // NB: must test Far0==0 because vertices are reallocated in preRender() if a change of Far occurs. if(!isRenderClipped() && Far0==0 && pVert->OwnerBlock->visibleTile()) { pVert->Index= CLandscapeGlobals::CurrentTileVBAllocator->allocateVertex(); } }

void NL3D::CPatch::checkDeleteVertexVBFar (  CTessFarVertex *  pVert  )  [private]

Definition at line 1571 of file patch_render.cpp. References NL3D::CTessFarVertex::Index0, NL3D::CTessFarVertex::Index1, isRenderClipped(), nlassert, NL3D::CTessFarVertex::OwnerBlock, NL3D::CTessBlock::visibleFar0(), and NL3D::CTessBlock::visibleFar1(). Referenced by NL3D::CTessFace::doMerge(). { nlassert(pVert); // If visible, and Far0 in !Tile Mode, ok, the vertex exist in VB, so delete. // NB: must test Far0>0 because vertices are deleted in preRender() if a change of Far occurs. if(!isRenderClipped() && Far0>0 && pVert->OwnerBlock->visibleFar0() ) { CLandscapeGlobals::CurrentFar0VBAllocator->deleteVertex(pVert->Index0); } // Idem for Far1 if(!isRenderClipped() && Far1>0 && pVert->OwnerBlock->visibleFar1() ) { CLandscapeGlobals::CurrentFar1VBAllocator->deleteVertex(pVert->Index1); } }

void NL3D::CPatch::checkDeleteVertexVBNear (  CTessNearVertex *  pVert  )  [private]

Definition at line 1589 of file patch_render.cpp. References NL3D::CTessNearVertex::Index, isRenderClipped(), nlassert, NL3D::CTessNearVertex::OwnerBlock, and NL3D::CTessBlock::visibleTile(). Referenced by NL3D::CTessFace::deleteTileUv(). { nlassert(pVert); // If visible, and Far0 in Tile Mode, ok, the vertex exist in VB, so delete. // NB: must test Far0==0 because vertices are deleted in preRender() if a change of Far occurs. if(!isRenderClipped() && Far0==0 && pVert->OwnerBlock->visibleTile() ) { CLandscapeGlobals::CurrentTileVBAllocator->deleteVertex(pVert->Index); } }

void NL3D::CPatch::checkFillVertexVBFar (  CTessFarVertex *  pVert  )  [private]

Definition at line 1522 of file patch_render.cpp. References fillFar0VertexVB(), fillFar1VertexVB(), isRenderClipped(), nlassert, NL3D::CTessFarVertex::OwnerBlock, NL3D::CTessBlock::visibleFar0(), and NL3D::CTessBlock::visibleFar1(). Referenced by bind(), NL3D::CTessFace::split(), NL3D::CTessFace::splitRectangular(), and NL3D::CTessFace::updateNearFarVertices(). { nlassert(pVert); // If visible, and Far0 in !Tile Mode, try to fill. // NB: must test Far0>0 because vertices are reallocated in preRender() if a change of Far occurs. if(!isRenderClipped() && Far0>0 && pVert->OwnerBlock->visibleFar0()) { if( !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() ) fillFar0VertexVB(pVert); } // Idem for Far1 if(!isRenderClipped() && Far1>0 && pVert->OwnerBlock->visibleFar1()) { if( !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() ) fillFar1VertexVB(pVert); } }

void NL3D::CPatch::checkFillVertexVBNear (  CTessNearVertex *  pVert  )  [private]

Definition at line 1556 of file patch_render.cpp. References fillTileVertexVB(), isRenderClipped(), nlassert, NL3D::CTessNearVertex::OwnerBlock, and NL3D::CTessBlock::visibleTile(). Referenced by NL3D::CTessFace::checkCreateFillTileVB(), NL3D::CTessFace::checkFillTileVB(), and NL3D::CTessFace::updateNearFarVertices(). { nlassert(pVert); // If visible, and Far0 in Tile Mode, try to fill. // NB: must test Far0==0 because vertices are reallocated in preRender() if a change of Far occurs. if(!isRenderClipped()&& Far0==0 && pVert->OwnerBlock->visibleTile() ) { // try to fill. if( !CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs() ) fillTileVertexVB(pVert); } }

void NL3D::CPatch::clearTessBlocks (   )  [private]

Definition at line 669 of file patch.cpp. References NL3D::CLandscape::_VegetableManager, deleteAllVegetableIgs(), NL3D::CVegetableManager::deleteClipBlock(), getLandscape(), TessBlockRefCount, TessBlocks, uint, NL3D::CLandscape::unlinkPatchFromNearUL(), and VegetableClipBlocks. Referenced by decRefTessBlocks(), makeRoots(), and release(). { uint i; // Vegetable management //========== // if compiled. if(Zone) { CVegetableManager *vegetableManager= getLandscape()->_VegetableManager; // delete still existing vegetable Igs. deleteAllVegetableIgs(); // delete ClipBlocks. for(i=0; i<VegetableClipBlocks.size(); i++) { vegetableManager->deleteClipBlock(VegetableClipBlocks[i]); } contReset(VegetableClipBlocks); } // updateLighting management. //========== if(Zone) { // remove patch from Near updateLighting, since no more TessBlock lightmap can exist. getLandscape()->unlinkPatchFromNearUL(this); } // Delete TessBlocks //========== TessBlockRefCount=0; contReset(TessBlocks); }

void NL3D::CPatch::compile (  CZone *  z, uint  patchId, uint8  orderS, uint8  orderT, CTessVertex *  baseVertices[4], float  errorSize = 0 )

compile a valid patch. (init) Call this method before any other. Zone and Control points must be valid before calling compile(). This is an ERROR to call compile() two times. Parameters: z  zone where the patch must be binded. orderS  the Tile order in S direction: 2,4,8,16. orderT  the Tile order in T direction: 2,4,8,16. errorSize  if 0, setup() compute himself the errormetric of the patch. May be setup to surface of patch, modulated by tangents and displacement map. Definition at line 1283 of file patch.cpp. References _ULNearNext, _ULNearPrec, BaseVertices, computeDefaultErrorSize(), ErrorSize, NLMISC::getPowerOf2(), NL3D::CTessBlock::init(), makeRoots(), MasterBlock, min, nlassert, sint, SquareLimitLevel, TessBlockLimitLevel, TileLimitLevel, uint, uint16, uint8, and z. Referenced by NL3D::CZone::compile(). { nlassert(z); Zone= z; // For updateLighting, get the correct pointer now. // Init UL circular list to me _ULNearPrec= this; _ULNearNext= this; // Once the patch is inserted and compiled in a zone, it is ready to be rendered. // init the MasterBlock. MasterBlock.init(this); // only 65536 patch per zone allowed. nlassert(patchId<0x10000); PatchId= (uint16)patchId; if(errorSize==0) computeDefaultErrorSize(); else ErrorSize= errorSize; nlassert(orderS==2 || orderS==4 || orderS==8 || orderS==16); nlassert(orderT==2 || orderT==4 || orderT==8 || orderT==16); nlassert (OrderS==orderS); nlassert (OrderT==orderT); // Compile additional infos. sint ps= getPowerOf2(orderS) , pt= getPowerOf2(orderT); sint pmin= min(ps,pt); sint pmax= max(ps,pt); // Rectangular patch OK. // Work, since patch 1xX are illegal. => The TileLimitLevel is at least 2 level distant from the time where // the rectangular patch is said "un-rectangular-ed" (tesselation looks like square). Hence, there is no problem // with rectangular UV geomorph (well don't bother me, make a draw :) ). TileLimitLevel= pmin*2 + pmax-pmin; // A TessBlock is a 2*2 tile. This simple formula works because patch 1xX are illegal. TessBlockLimitLevel= TileLimitLevel-2; // This tell us when the tess face is "un-rectangular-ed" (to say a square). Before, it is a "rectangular" face, // which has a strange fxxxxxg split. // If patch is square, then SquareLimitLevel=0 (ok!!). SquareLimitLevel= pmax-pmin; // Bind vertices, to zone base vertices. BaseVertices[0]= baseVertices[0]; BaseVertices[1]= baseVertices[1]; BaseVertices[2]= baseVertices[2]; BaseVertices[3]= baseVertices[3]; // build Sons. makeRoots(); }

CVector NL3D::CPatch::computeContinousVertex (  float  s, float  t )  const

Same as computeVertex, but special accurate version for CVisualCollisionEntity. If on a corner of the patch (0,0), (0,1) ...., take directly the BaseVertices[] result if on a border of a patch (ie s==0, s==1, t==0 or t==1), also compute the vertex of the neighbor patch (if any), and then average the result. This ensure that tesselation generated is perfectly continous, even across patchs of same or different zones. This feature is very important for CVisualCollisionEntity::snapToGround() Definition at line 1363 of file patch.cpp. References BaseVertices, NL3D::CPatchUVLocator::build(), computeVertex(), computeVertexButCorner(), NL3D::CTessVertex::EndPos, getBindNeighbor(), getOrderS(), getOrderT(), NL3D::CPatchUVLocator::locateUV(), nlassert, nlstop, s, NL3D::CPatchUVLocator::selectPatch(), sint, t, uint, NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. { // must be compiled nlassert(Zone); // Test is on a edge/corner of the patch sint edgeIdS= -1; sint edgeIdT= -1; if(s==0) edgeIdS= 0; else if(s==1) edgeIdS= 2; if(t==0) edgeIdT= 3; else if(t==1) edgeIdT= 1; // test if on a corner if(edgeIdS>=0 && edgeIdT>=0) { // return the baseVertex according to edge falgs if(edgeIdS==0 && edgeIdT==3) return BaseVertices[0]->EndPos; if(edgeIdS==0 && edgeIdT==1) return BaseVertices[1]->EndPos; if(edgeIdS==2 && edgeIdT==1) return BaseVertices[2]->EndPos; if(edgeIdS==2 && edgeIdT==3) return BaseVertices[3]->EndPos; nlstop; // Error, but Avoid warning return CVector::Null; } // test if on an edge else if(edgeIdS>=0 || edgeIdT>=0) { // Yes, must compute myslef CVector vertexOnMe= computeVertex(s,t); // Then, must compute my neighbor. sint edgeId; if(edgeIdS>=0) edgeId= edgeIdS; else edgeId= edgeIdT; // Get my neighbor, if any. CBindInfo bindInfo; getBindNeighbor(edgeId, bindInfo); // Fast reject: if no neighbor on the edge, just return my pos. if(!bindInfo.Zone) { return vertexOnMe; } // else must get vertex pos of my neighbor, and average. else { // use a CPatchUVLocator to get UV in neighbor patch CPatchUVLocator uvLocator; uvLocator.build(this, edgeId, bindInfo); // UVlocator use OrderS/OrderT coordinate system. CVector2f stTileIn, stTileOut; stTileIn.x= s * getOrderS(); stTileIn.y= t * getOrderT(); // transform coordinate to get into the neigbhor patch uint pid= uvLocator.selectPatch(stTileIn); CPatch *nebPatch; uvLocator.locateUV(stTileIn, pid, nebPatch, stTileOut); // transform neigbhor coord in 0..1 coordinate space. stTileOut.x/= nebPatch->getOrderS(); stTileOut.y/= nebPatch->getOrderT(); // and compute vertex. NB: if binded on 2 or 4 patch, it is then possible that stTileOut is on a // a corner ( (0,0), (0,1) ...). // In this case, we must use the precomputed Vertex pos, for completeness. bool onCorner; CVector vertexOnNeb= nebPatch->computeVertexButCorner(stTileOut.x, stTileOut.y, onCorner); // If the neighbor is on a corner, then use its corner value. if(onCorner) return vertexOnNeb; else { // Average the 2 and return this result. vertexOnMe+= vertexOnNeb; vertexOnMe/= 2; return vertexOnMe; } } } // else, std case else return computeVertex(s, t); }

void NL3D::CPatch::computeCurrentTLILightmapDiv2 (  NLMISC::CRGBA *  array  )  const

For CTextureFar, compute current TLI Lightmap at tile level. array should be allocated of at least sqr(NL_MAX_TILES_BY_PATCH_EDGE+1). Definition at line 1805 of file patch_lightmap.cpp. References NLMISC::CRGBA::B, NLMISC::CRGBA::G, NLMISC::CRGBA::R, uint, x, and y. Referenced by NL3D::CTextureFar::rebuildPatch(). { // Size of TileLightInfluences uint wTLI= (OrderS>>1)+1; uint hTLI= (OrderT>>1)+1; // colros at corners of tiles size. uint wTC= OrderS+1; uint wTCx2= wTC*2; uint hTC= OrderT+1; uint x, y; // Compute TLI colors at each corner of each TessBlocks. //============= for(y=0;y<hTLI;y++) { // store every 2 tiles corners. CRGBA *dst= array + y*2*wTC; for(x=0;x<wTLI;x++) { *dst= getCurrentTLIColor(x, y); dst->R >>= 1; dst->G >>= 1; dst->B >>= 1; // skip 2 tiles corners. dst++; dst++; } } // Compute TLI colors at each corner of each Tiles. //============= // Compute corner at middle of vertical TessBlock edges. for(y=0;y<hTC-1;y+=2) { CRGBA *dst= array + y*wTC; for(x=0;x<wTC;x+=2) { // Average midlle with cur and next. (dst+wTC)->avg2RGBOnly(*dst, *(dst + wTCx2) ); // skip 2 tiles corners. dst++; dst++; } } // Compute corner at middle of horizontal TessBlock edges, and at middle of TessBlock. for(y=0;y<hTC;y++) { CRGBA *dst= array + y*wTC; for(x=0;x<wTC-1;x+=2) { // Average midlle with cur and next. (dst+1)->avg2RGBOnly(*dst, *(dst+2)); // skip 2 tiles corners. dst++; dst++; } } }

void NL3D::CPatch::computeDefaultErrorSize (   )  [private]

Definition at line 206 of file patch.cpp. References ErrorSize, unpackIntoCache(), and NL3D::CBezierPatch::Vertices. Referenced by compile(). { CBezierPatch &p= *unpackIntoCache(); CVector &v0= p.Vertices[0]; CVector &v1= p.Vertices[1]; CVector &v2= p.Vertices[2]; // \todo yoyo: TODO_NOISE: modulate this value with tangents (roundiness of patch), and with the displacement map. ErrorSize= ((v1 - v0)^(v2 - v0)).norm(); }

float NL3D::CPatch::computeDisplaceCornerSmooth (  float  s, float  t, sint8  smoothBorderX, sint8  smoothBorderY )  const [private]

compute the smoothed displacement for s,t ([0;OrderS], [0;OrderT]). Special case on corner. Definition at line 471 of file patch_noise.cpp. References NL3D::CPatchUVLocator::build(), NL3D::computeDisplaceBilinear(), computeDisplaceInteriorSmooth(), computeDisplaceRaw(), computeDisplaceRawOnNeighbor(), getBindNeighbor(), NL3D::CPatchUVLocator::locateUV(), nlassert, nlstop, NL3D::noiseFloor(), s, NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint8, t, uint, NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by computeNoise(). { // compute the value across the corner (enjoy!!) // NB: Only corners with Edges==4 and corners on a bind are correclty supported. // ignore problems with corner which nbEdges!=4, because Blend of normals blend to 0 on corner (see computenoise()). float sTile= s; float tTile= t; CBindInfo bindInfoX; CBindInfo bindInfoY; uint edgeX=0; uint edgeY=0; // both must be not null nlassert( (smoothBorderX!=0) && (smoothBorderY!=0) ); // Get the edge against we must share displace. if(smoothBorderX==-1) edgeX=0; else if(smoothBorderX==1) edgeX=2; else nlstop; if(smoothBorderY==1) edgeY=1; else if(smoothBorderY==-1) edgeY=3; else nlstop; // Build the bindInfo against those 2 edge. getBindNeighbor(edgeX, bindInfoX); getBindNeighbor(edgeY, bindInfoY); // Fast reject: if no neighbor on one of the edge, just do a simple computeDisplaceInteriorSmooth. if(!bindInfoX.Zone || !bindInfoY.Zone) return computeDisplaceInteriorSmooth(s, t); else { float ret; // compute bi-linear weight factors. float sInc, tInc, sa, ta, sa1, ta1; computeDisplaceBilinear(sTile, tTile, sInc, tInc, sa, ta, sa1, ta1); // Manage limit case: if bilinear has not chosen the good direction (because of floor and orientation). // eg on Right edge: This case arise if sDecimal==0, so if sa==sa1==0.5f. result is that // smoothBorderX is != than sInc on right border. same reasoning with downBorder (smoothBorderY=1). // NO NEED TO DO HERE, because sInc or tInc are not used at all. // compute Neighboring info. CPatchUVLocator uvLocatorX; CPatchUVLocator uvLocatorY; uvLocatorX.build(this, edgeX, bindInfoX); uvLocatorY.build(this, edgeY, bindInfoY); /* NB: see floor problems note in computeDisplaceEdgeSmooth(); */ sTile= noiseFloor(sTile) + 0.5f; tTile= noiseFloor(tTile) + 0.5f; // If we were exactly on the superior edge, prec compute is false... so correct this here. if(sTile>OrderS) sTile--; if(tTile>OrderT) tTile--; // Bilinear across a corner. CVector2f stTileIn, stIn; CVector2f stTileOut, stOut; CPatch *patchOut; uint patchId; // compute contribution of our patch. ret = computeDisplaceRaw(sTile,tTile, s,t) * sa * ta; // compute contribution of the patch on the left/right side. same reasoning as in computeDisplaceEdgeSmooth(); stIn.set(s, t); stTileIn.set(sTile+smoothBorderX, tTile); patchId= uvLocatorX.selectPatch(stTileIn); uvLocatorX.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocatorX.locateUV(stIn, patchId, patchOut, stOut); ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta; // compute contribution of the patch on the up/down side. same reasoning as in computeDisplaceEdgeSmooth(); stIn.set(s, t); stTileIn.set(sTile, tTile+smoothBorderY); patchId= uvLocatorY.selectPatch(stTileIn); uvLocatorY.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocatorY.locateUV(stIn, patchId, patchOut, stOut); ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa * ta1; /* compute contribution of the patch adjacent to me. There is multiple case to consider here. Take example with corner=0 (ie smBdX=smBdY=-1): - if we are a normal corner with 4 edges, take the result from the left patch of our top patch. - if the corner is on a bind Edge, the top patch may be the bigger patch, so don't take the result from his neighbor (of course). - if we are a normal corner with N!=4 edges, just do same thing than if N==4. this is false but don't bother. To solve smoothly cases 1 and 2, use computeDisplaceRawOnNeighbor(). This method, if nessecary, look on his neighbor to compute the value. */ stIn.set(s, t); stTileIn.set(sTile+smoothBorderX, tTile+smoothBorderY); // look on our "top" patch (this is arbitrary). patchId= uvLocatorY.selectPatch(stTileIn); uvLocatorY.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocatorY.locateUV(stIn, patchId, patchOut, stOut); ret+= patchOut->computeDisplaceRawOnNeighbor(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta1; return ret; } }

float NL3D::CPatch::computeDisplaceEdgeSmooth (  float  s, float  t, sint8  smoothBorderX, sint8  smoothBorderY )  const [private]

compute the smoothed displacement for s,t ([0;OrderS], [0;OrderT]). Special case on edge. Definition at line 288 of file patch_noise.cpp. References NL3D::CPatchUVLocator::build(), NL3D::computeDisplaceBilinear(), computeDisplaceInteriorSmooth(), computeDisplaceRaw(), getBindNeighbor(), NL3D::CPatchUVLocator::locateUV(), nlassert, nlstop, NL3D::noiseFloor(), s, NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint8, t, uint, NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by computeNoise(). { float sTile= s; float tTile= t; CBindInfo bindInfo; uint edge=0; // only one must be not null nlassert( (smoothBorderX==0) != (smoothBorderY==0) ); // Get the edge against we must share displace. if(smoothBorderX==-1) edge=0; else if(smoothBorderY==1) edge=1; else if(smoothBorderX==1) edge=2; else if(smoothBorderY==-1) edge=3; else nlstop; // Build the bindInfo against this edge. getBindNeighbor(edge, bindInfo); // Fast reject: if no neighbor, just do a simple computeDisplaceInteriorSmooth. if(!bindInfo.Zone) return computeDisplaceInteriorSmooth(s, t); // else, look for result in neighborhood. else { float ret; // compute bi-linear weight factors. float sInc, tInc, sa, ta, sa1, ta1; computeDisplaceBilinear(sTile, tTile, sInc, tInc, sa, ta, sa1, ta1); // Manage limit case: if bilinear has not chosen the good direction (because of floor and orientation). // eg on Right edge: This case arise if sDecimal==0, so if sa==sa1==0.5f. result is that // smoothBorderX is != than sInc on right border. same reasoning with downBorder (smoothBorderY=1). // NO NEED TO DO HERE, because sInc or tInc is not used if it is bad (smoothBorder? used instead). // and no need to correct sa, sa1, because in this case they are both equal to 0.5. // compute Neighboring info. CPatchUVLocator uvLocator; uvLocator.build(this, edge, bindInfo); /* NB: there is floor problems with neighbors: - difference of orientation => uv.v=1. This point to the 1th tile. But this is not the same, if v goes to up, or goes to down. - if multiple bind, problem at limit (eg a bind 1/2 on edge 0 with OrdertT=8, when uv.v= 4). because, selection of the patch is dependent of orientation too. To avoid them, just take center of (sTile, tTile) to remove ambiguity. This works because computeDisplaceRaw() use sTile, tTile to get the noiseMap, so the decimal part is not used. Notice that we do this AFTER computeDisplaceBilinear() of course. */ sTile= noiseFloor(sTile) + 0.5f; tTile= noiseFloor(tTile) + 0.5f; // If we were exactly on the superior edge, prec compute is false... so correct this here. if(sTile>OrderS) sTile--; if(tTile>OrderT) tTile--; // Bilinear across an edge (enjoy!!). CVector2f stTileIn, stIn; CVector2f stTileOut, stOut; CPatch *patchOut; uint patchId; // if vertical edge. if(smoothBorderX!=0) { // compute contribution of our patch. ret = computeDisplaceRaw(sTile,tTile, s,t) * sa * ta; ret+= computeDisplaceRaw(sTile,tTile+tInc, s,t) * sa * ta1; // compute contribution of next(s) patchs. // contribution of next at tTile. // Keep the same coordinate. stIn.set(s, t); // But look for the neighbor noise tile. stTileIn.set(sTile+smoothBorderX, tTile); // change basis: find the s,t on the neighbor patch. patchId= uvLocator.selectPatch(stTileIn); uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocator.locateUV(stIn, patchId, patchOut, stOut); // Compute displace, and bi-linear on the neighbor patch. ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta; // contribution of next at tTile+tInc (same reasoning). stIn.set(s, t); stTileIn.set(sTile+smoothBorderX, tTile+tInc); patchId= uvLocator.selectPatch(stTileIn); uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocator.locateUV(stIn, patchId, patchOut, stOut); ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta1; } // else if horizontal edge. else { // same reasoning as above. // compute contribution of our patch. ret = computeDisplaceRaw(sTile, tTile, s,t) * sa * ta; ret+= computeDisplaceRaw(sTile+sInc,tTile, s,t) * sa1 * ta; // compute contribution of next(s) patchs. // contribution of next at tTile. stIn.set(s, t); stTileIn.set(sTile, tTile+smoothBorderY); patchId= uvLocator.selectPatch(stTileIn); uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocator.locateUV(stIn, patchId, patchOut, stOut); ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa * ta1; // contribution of next at tTile+tInc (same reasoning). stIn.set(s, t); stTileIn.set(sTile+sInc, tTile+smoothBorderY); patchId= uvLocator.selectPatch(stTileIn); uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocator.locateUV(stIn, patchId, patchOut, stOut); ret+= patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y) * sa1 * ta1; } return ret; } }

float NL3D::CPatch::computeDisplaceInteriorSmooth (  float  s, float  t )  const [private]

compute the smoothed displacement for s,t ([0;OrderS], [0;OrderT]). Definition at line 258 of file patch_noise.cpp. References NL3D::computeDisplaceBilinear(), computeDisplaceRawCoordinates(), computeDisplaceRawInteger(), s, sint, and t. Referenced by computeDisplaceCornerSmooth(), computeDisplaceEdgeSmooth(), and computeNoise(). { float sTile= s; float tTile= t; float ret; // compute bi-linear weight factors. float sInc, tInc, sa, ta, sa1, ta1; computeDisplaceBilinear(sTile, tTile, sInc, tInc, sa, ta, sa1, ta1); // NB: to have smooth transition, must keep the same (s,t), so we do a transition with the noise tile of // our neigbhor, but under us. // speed up, using just one computeDisplaceRawCoordinates(), and multiple computeDisplaceRawInteger(). sint ts,tt,ms,mt; computeDisplaceRawCoordinates(sTile, tTile, s, t, ts, tt, ms, mt); sint sIncInt= (sint) sInc; sint tIncInt= (sint) tInc; ret = computeDisplaceRawInteger(ts, tt, ms,mt) * sa * ta; ret+= computeDisplaceRawInteger(ts+sIncInt, tt, ms,mt) * sa1 * ta; ret+= computeDisplaceRawInteger(ts, tt+tIncInt, ms,mt) * sa * ta1; ret+= computeDisplaceRawInteger(ts+sIncInt, tt+tIncInt, ms,mt) * sa1 * ta1; return ret; }

float NL3D::CPatch::computeDisplaceRaw (  float  sTile, float  tTile, float  s, float  t )  const [private]

compute the displacement for s,t ([0;OrderS], [0;OrderT]) (sTile, tTile) choose what NoiseMap to use, and (s,t) choose the coordinate in the patch to compute this NoiseMap. Any rotation of the NoiseMap is included in this method. NB: s,t does not have to be clamped to ([0;OrderS], [0;OrderT]). Definition at line 219 of file patch_noise.cpp. References computeDisplaceRawCoordinates(), computeDisplaceRawInteger(), s, sint, and t. Referenced by computeDisplaceCornerSmooth(), computeDisplaceEdgeSmooth(), and computeDisplaceRawOnNeighbor(). { sint ts,tt,ms,mt; computeDisplaceRawCoordinates(sTile, tTile, s, t, ts, tt, ms, mt); return computeDisplaceRawInteger(ts, tt, ms, mt); }

void NL3D::CPatch::computeDisplaceRawCoordinates (  float  sTile, float  tTile, float  s, float  t, sint &  ts, sint &  tt, sint &  ms, sint &  mt )  const [private]

compute the smoothed displacement for s,t ([0;OrderS], [0;OrderT]). Special case on corner. Definition at line 168 of file patch_noise.cpp. References NL3D_TILE_NOISE_MAP_SIZE, NL3D_TILE_NOISE_MAP_TILE_FACTOR, NL3D::noiseFloor(), NoiseRotation, s, sint, t, NLMISC::CUV::U, NLMISC::CUV::V, and v. Referenced by computeDisplaceInteriorSmooth(), and computeDisplaceRaw(). { // Choose the noiseMap. // =============================== // Compute coordinate in the patch. ts= noiseFloor(sTile); tt= noiseFloor(tTile); // Sample the noiseMap with (s,t). // =============================== // scale the map. float u= s * NL3D_TILE_NOISE_MAP_TILE_FACTOR; float v= t * NL3D_TILE_NOISE_MAP_TILE_FACTOR; // Speed rotation. CUV uv; switch(NoiseRotation & 3) { case 0: uv.U= u; uv.V= v; break; case 1: uv.U= NL3D_TILE_NOISE_MAP_SIZE-v; uv.V= u; break; case 2: uv.U= NL3D_TILE_NOISE_MAP_SIZE-u; uv.V= NL3D_TILE_NOISE_MAP_SIZE-v; break; case 3: uv.U= v; uv.V= NL3D_TILE_NOISE_MAP_SIZE-u; break; } // direct map (no bilinear, no round, the case where s,t < 1/4 of a tile is very rare). ms= noiseFloor(uv.U); mt= noiseFloor(uv.V); // Manage Tiling (add NL3D_TILE_NOISE_MAP_SIZE*1 should be sufficient, but take margin). ms= (ms + (NL3D_TILE_NOISE_MAP_SIZE*256)) & (NL3D_TILE_NOISE_MAP_SIZE-1); mt= (mt + (NL3D_TILE_NOISE_MAP_SIZE*256)) & (NL3D_TILE_NOISE_MAP_SIZE-1); }

float NL3D::CPatch::computeDisplaceRawInteger (  sint  ts, sint  tt, sint  ms, sint  mt )  const [private]

compute the smoothed displacement for s,t ([0;OrderS], [0;OrderT]). Special case on corner. Definition at line 136 of file patch_noise.cpp. References NLMISC::clamp(), NL3D::CZone::getLandscape(), NL3D::CTileBank::getTileNoiseMap(), getZone(), NL3D_NOISE_MAX, NL3D_TILE_NOISE_MAP_SIZE, NL3D::CTileNoiseMap::Pixels, sint, sint8, NL3D::CLandscape::TileBank, Tiles, and uint. Referenced by computeDisplaceInteriorSmooth(), and computeDisplaceRaw(). { // Choose the noiseMap. // =============================== clamp(ts, 0, OrderS-1); clamp(tt, 0, OrderT-1); uint tileId= tt*OrderS + ts; // Get the tile for pass0. This is the principal tile, and this one tells what noise to take. sint tileNumber= Tiles[tileId].Tile[0]; // Get the subNoise from tileElement. uint tileSubNoise= Tiles[tileId].getTileSubNoise(); // retrieve the wanted noiseMap. CTileNoiseMap *noiseMap; noiseMap = getZone()->getLandscape()->TileBank.getTileNoiseMap (tileNumber, tileSubNoise); if (noiseMap == NULL) return 0.0f; // Sample the noiseMap with (s,t). // =============================== // sample from map. sint8 pix= noiseMap->Pixels[mt*NL3D_TILE_NOISE_MAP_SIZE + ms]; // normalize. return (float)pix * (NL3D_NOISE_MAX / 127.f); }

float NL3D::CPatch::computeDisplaceRawOnNeighbor (  float  sTile, float  tTile, float  s, float  t )  const [private]

usefull only for computeDisplaceCornerSmooth(). This method, if nessecary (ie sTile or tTile <0 or >Order), look on his neighbor to compute the value. Definition at line 422 of file patch_noise.cpp. References NL3D::CPatchUVLocator::build(), computeDisplaceRaw(), getBindNeighbor(), NL3D::CPatchUVLocator::locateUV(), s, NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint, t, uint, NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by computeDisplaceCornerSmooth(). { sint edge= -1; // look on what neighbor patch we must find the value (if any). if(sTile<0) edge=0; else if(tTile>OrderT) edge=1; else if(sTile>OrderS) edge=2; else if(tTile<0) edge=3; // If the location is In the patch, just return normal value. if(edge==-1) return computeDisplaceRaw(sTile, tTile, s, t); // else must find on neighbor. else { CBindInfo bindInfo; getBindNeighbor(edge, bindInfo); // Fast reject: if no neighbor on the edge, just do a simple computeDisplaceRaw() if(!bindInfo.Zone) { return computeDisplaceRaw(sTile, tTile, s, t); } // else must find on neighbor. else { CPatchUVLocator uvLocator; uvLocator.build(this, edge, bindInfo); CVector2f stTileIn, stIn; CVector2f stTileOut, stOut; CPatch *patchOut; uint patchId; // look on neighbor. same reasoning as in computeDisplaceEdgeSmooth(); stIn.set(s, t); stTileIn.set(sTile, tTile); patchId= uvLocator.selectPatch(stTileIn); uvLocator.locateUV(stTileIn, patchId, patchOut, stTileOut); uvLocator.locateUV(stIn, patchId, patchOut, stOut); return patchOut->computeDisplaceRaw(stTileOut.x, stTileOut.y, stOut.x, stOut.y); } } }

void NL3D::CPatch::computeGeomorphAlphaFar1VertexListVB (  CTessList< CTessFarVertex > &  vertList  )  [private]

Definition at line 1329 of file patch_render.cpp. References NLMISC::CRGBA::A, NL3D::CTessList< T >::begin(), NLMISC::clamp(), NL3D::CTessFarVertex::Index1, NL3D::CTessNodeList::Next, OOTransitionSqrDelta, NL3D::CTessVertex::Pos, NL3D::CTessFarVertex::Src, TransitionSqrMin, and uint8. Referenced by computeSoftwareGeomorphAndAlpha(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { static uint8 *CurVBPtr; // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize; // NB: the filling order of data is important, for AGP write combiners. // Set Geomorphed Position. Set it local to the current center of landscape *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition; // Set Alpha color. static CRGBA col(255,255,255,255); // For Far1, use alpha fro transition. // Prefer Use Pos, because of caching. So little difference between Soft and VertexProgram mode. float f= (pVert->Src->Pos - CLandscapeGlobals::RefineCenter).sqrnorm(); f= (f-TransitionSqrMin) * OOTransitionSqrDelta; clamp(f,0,1); col.A= (uint8)(f*255); *(CRGBA*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.ColorOff)= col; } }

void NL3D::CPatch::computeGeomorphFar0VertexListVB (  CTessList< CTessFarVertex > &  vertList  )  [private]

Definition at line 1311 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessFarVertex::Index0, NL3D::CTessNodeList::Next, NL3D::CTessVertex::Pos, NL3D::CTessFarVertex::Src, and uint8. Referenced by computeSoftwareGeomorphAndAlpha(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { static uint8 *CurVBPtr; // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize; // Set Geomorphed Position. Set it local to the current center of landscape *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition; } }

void NL3D::CPatch::computeGeomorphTileVertexListVB (  CTessList< CTessNearVertex > &  vertList  )  [private]

Definition at line 1359 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessNearVertex::Index, NL3D::CTessNodeList::Next, NL3D::CTessVertex::Pos, NL3D::CTessNearVertex::Src, and uint8. Referenced by computeSoftwareGeomorphAndAlpha(). { // Traverse the vertList. CTessNearVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next) { static uint8 *CurVBPtr; // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentTileVBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index * CLandscapeGlobals::CurrentTileVBInfo.VertexSize; // Set Geomorphed Position. Set it local to the current center of landscape *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition; } }

void NL3D::CPatch::computeGeomorphVertexList (  CTessList< CTessFarVertex > &  vertList  )  [private]

Definition at line 1298 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessVertex::computeGeomPos(), NL3D::CTessNodeList::Next, and NL3D::CTessFarVertex::Src. Referenced by computeSoftwareGeomorphAndAlpha(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { // compute geomorph. pVert->Src->computeGeomPos(); } }

void NL3D::CPatch::computeNearBlockLightmap (  uint  ts, uint  tt, NLMISC::CRGBA *  lightText )  [private]

Definition at line 864 of file patch_lightmap.cpp. References NL3D::CPatchUVLocator::build(), computeTileLightmap(), computeTileLightmapEdge(), computeTileLightmapPixel(), computeTileLightmapPixelAroundCorner(), NL3D::CPatch::CBindInfo::Edge, getBindNeighbor(), getCornerSmoothFlag(), getSmoothFlag(), NL3D::CPatchUVLocator::locateUV(), NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE_SHIFT, NL_TILE_LIGHTMAP_SIZE, nlassert, NL3D::CPatchUVLocator::sameEdgeOrder(), NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint, src, stride, uint, v, NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by getTileLightMap(), and updateTessBlockLighting(). { sint ts= uts; sint tt= utt; // hardcoded for 10x10. nlassert(NL_TILE_LIGHTMAP_SIZE==10); CRGBA *dest; uint edge; uint corner; // Compute center of the TessBlock: the 2x2 tiles. //================= // compute tile 0,0 of the tessBlock. must decal of 1 pixel. dest= lightText+NL_TILE_LIGHTMAP_SIZE+1; computeTileLightmap(ts, tt, dest, NL_TILE_LIGHTMAP_SIZE); // compute tile 1,0 of the tessBlock. must decal of 1 pixel. dest= lightText + NL_LUMEL_BY_TILE + NL_TILE_LIGHTMAP_SIZE+1 ; computeTileLightmap(ts+1, tt, dest, NL_TILE_LIGHTMAP_SIZE); // compute tile 0,1 of the tessBlock. must decal of 1 pixel. dest= lightText + NL_LUMEL_BY_TILE*NL_TILE_LIGHTMAP_SIZE + NL_TILE_LIGHTMAP_SIZE+1 ; computeTileLightmap(ts, tt+1, dest, NL_TILE_LIGHTMAP_SIZE); // compute tile 1,1 of the tessBlock. must decal of 1 pixel. dest= lightText + NL_LUMEL_BY_TILE*NL_TILE_LIGHTMAP_SIZE + NL_LUMEL_BY_TILE + NL_TILE_LIGHTMAP_SIZE+1 ; computeTileLightmap(ts+1, tt+1, dest, NL_TILE_LIGHTMAP_SIZE); // Compute edges of the TessBlock. //================= bool edgeBorder[4]; // where are we on a border of a patch?? edgeBorder[0]= ( ts==0 ); edgeBorder[1]= ( tt == OrderT-2 ); edgeBorder[2]= ( ts == OrderS-2 ); edgeBorder[3]= ( tt==0 ); // For all edges. for(edge=0; edge<4; edge++) { // compute dest info. //============== // Are we on a vertical edge or horizontal edge?? uint stride= (edge&1)==0? NL_TILE_LIGHTMAP_SIZE : 1; // must compute on which tile we must find info. sint decalS=0; sint decalT=0; // and must compute ptr, where we store the result of the edge. switch(edge) { case 0: decalS=-1; dest= lightText + 0 + NL_TILE_LIGHTMAP_SIZE; break; case 1: decalT= 2; dest= lightText + 1 + (NL_TILE_LIGHTMAP_SIZE-1)*NL_TILE_LIGHTMAP_SIZE; break; case 2: decalS= 2; dest= lightText + (NL_TILE_LIGHTMAP_SIZE-1) + NL_TILE_LIGHTMAP_SIZE; break; case 3: decalT=-1; dest= lightText + 1; break; }; // compute the second tile dest info. CRGBA *dest2; sint decalS2; sint decalT2; // if vertical edge. if((edge&1)==0) { // Next Y tile. dest2= dest + NL_LUMEL_BY_TILE*NL_TILE_LIGHTMAP_SIZE; decalS2= decalS; decalT2= decalT+1; } else { // Next X tile. dest2= dest + NL_LUMEL_BY_TILE; decalS2= decalS+1; decalT2= decalT; } // If we are not on a border of a patch, just compute on the interior of the patch. //============== if(!edgeBorder[edge]) { // find the result on the mirrored border of us. First tile. computeTileLightmapEdge(ts+decalS, tt+decalT, (edge+2)&3, dest, stride, false); // find the result on the mirrored border of us. Second Tile. computeTileLightmapEdge(ts+decalS2, tt+decalT2, (edge+2)&3, dest2, stride, false); } // else, slightly complicated, must find the result on neighbor patch(s). //============== else { CPatchUVLocator uvLocator; CBindInfo bindInfo; bindInfo.Zone= NULL; // if smoothed edge, search the neighbor. if(getSmoothFlag(edge)) { // Build the bindInfo against this edge. getBindNeighbor(edge, bindInfo); // if ok, build the uv info against this edge. if(bindInfo.Zone) { uvLocator.build(this, edge, bindInfo); // if there is not same tile order across the edge, invalidate the smooth. // This is rare, so don't bother. if(!uvLocator.sameEdgeOrder()) bindInfo.Zone= NULL; } } // Fast reject: if no neighbor, or if not smoothed, or if edge order pb, just copy from my interior. if(!bindInfo.Zone) { CRGBA *src=0; switch(edge) { case 0: src= dest + 1; break; case 1: src= dest - NL_TILE_LIGHTMAP_SIZE; break; case 2: src= dest - 1; break; case 3: src= dest + NL_TILE_LIGHTMAP_SIZE; break; }; // fill the NL_LUMEL_BY_TILE*2 (8) pixels. for(uint n=NL_LUMEL_BY_TILE*2; n>0; n--, src+=stride, dest+=stride) *dest= *src; } // else, ok, get from neighbor. else { CVector2f stIn, stOut; CPatch *patchOut; uint patchId; uint edgeOut; bool inverse; // First Tile. //========= // to remove floor pbs, take the center of the wanted tile. stIn.set(ts+decalS + 0.5f, tt+decalT + 0.5f); patchId= uvLocator.selectPatch(stIn); uvLocator.locateUV(stIn, patchId, patchOut, stOut); // must find what edge on neighbor to compute, and if we must inverse (swap) result. // easy: the edge of the tile is the edge of the patch where we are binded. edgeOut= bindInfo.Edge[patchId]; // edge0 is oriented in T increasing order. edge1 is oriented in S increasing order. // edge2 is oriented in T decreasing order. edge3 is oriented in S decreasing order. // inverse is true if same sens on both edges (because of mirroring, sens should be different). inverse= (edge>>1)==(edgeOut>>1); // compute the lightmap on the edge of the neighbor. patchOut->computeTileLightmapEdge((sint)floor(stOut.x), (sint)floor(stOut.y), edgeOut, dest, stride, inverse); // Second Tile. //========= // same reasoning. stIn.set(ts+decalS2 + 0.5f, tt+decalT2 + 0.5f); patchId= uvLocator.selectPatch(stIn); uvLocator.locateUV(stIn, patchId, patchOut, stOut); edgeOut= bindInfo.Edge[patchId]; inverse= (edge>>1)==(edgeOut>>1); patchOut->computeTileLightmapEdge((sint)floor(stOut.x), (sint)floor(stOut.y), edgeOut, dest2, stride, inverse); } } } // Compute corners of the TessBlock. //================= bool cornerOnPatchEdge[4]; bool cornerOnPatchCorner[4]; // where are we on a edge border of a patch?? cornerOnPatchEdge[0]= edgeBorder[3] != edgeBorder[0]; cornerOnPatchEdge[1]= edgeBorder[0] != edgeBorder[1]; cornerOnPatchEdge[2]= edgeBorder[1] != edgeBorder[2]; cornerOnPatchEdge[3]= edgeBorder[2] != edgeBorder[3]; // where are we on a corner border of a patch?? cornerOnPatchCorner[0]= edgeBorder[3] && edgeBorder[0]; cornerOnPatchCorner[1]= edgeBorder[0] && edgeBorder[1]; cornerOnPatchCorner[2]= edgeBorder[1] && edgeBorder[2]; cornerOnPatchCorner[3]= edgeBorder[2] && edgeBorder[3]; // For all corners. for(corner=0; corner<4; corner++) { // compute dest info. //============== // must compute on which tile we must find info. sint decalS=0; sint decalT=0; // and must compute ptr, where we store the result of the corner. switch(corner) { case 0: decalS=-1; decalT=-1; dest= lightText + 0 + 0; break; case 1: decalS=-1; decalT= 2; dest= lightText + 0 + (NL_TILE_LIGHTMAP_SIZE-1)*NL_TILE_LIGHTMAP_SIZE; break; case 2: decalS= 2; decalT= 2; dest= lightText + (NL_TILE_LIGHTMAP_SIZE-1) + (NL_TILE_LIGHTMAP_SIZE-1)*NL_TILE_LIGHTMAP_SIZE; break; case 3: decalS= 2; decalT=-1; dest= lightText + (NL_TILE_LIGHTMAP_SIZE-1) + 0; break; }; // If we are not on a border of a patch, just compute on the interior of the patch. //============== // if the corner is IN the patch. if(!cornerOnPatchCorner[corner] && !cornerOnPatchEdge[corner]) { // what pixel to read. uint subS, subT; if(decalS==-1) subS= NL_LUMEL_BY_TILE-1; else subS= 0; if(decalT==-1) subT= NL_LUMEL_BY_TILE-1; else subT= 0; // find the result on the corner of the neighbor tile. computeTileLightmapPixel(ts+decalS, tt+decalT, subS, subT, dest); } else { // By default, fill the corner with our interior corner. Because other methods may fail. CRGBA *src=0; switch(corner) { case 0: src= dest + 1 + NL_TILE_LIGHTMAP_SIZE; break; case 1: src= dest + 1 - NL_TILE_LIGHTMAP_SIZE; break; case 2: src= dest - 1 - NL_TILE_LIGHTMAP_SIZE; break; case 3: src= dest - 1 + NL_TILE_LIGHTMAP_SIZE; break; }; // fill the pixel. *dest= *src; // get the coordinate of the corner, in our [0,Order] basis. get it at the center of the pixel. CBindInfo bindInfo; CPatchUVLocator uvLocator; CVector2f stIn, stOut; CPatch *patchOut; uint patchId; float decX, decY; static const float lumelSize= 1.f/NL_LUMEL_BY_TILE; static const float semiLumelSize= 0.5f*lumelSize; if(decalS==-1) decX= - semiLumelSize; else decX= 2+ semiLumelSize; if(decalT==-1) decY= - semiLumelSize; else decY= 2+ semiLumelSize; stIn.set( ts+decX, tt+decY); // if the corner is on One edge only of the patch. if(cornerOnPatchEdge[corner]) { // find the edge where to read this corner: hard edge after or before this corner. if(edgeBorder[corner]) edge= corner; else edge= (corner+4-1) & 3; // if this edge is smoothed, find on neighbor. if(getSmoothFlag(edge)) { // retrieve neigbhor info. getBindNeighbor(edge, bindInfo); // if neighbor present. if(bindInfo.Zone) { // Ok, search uv on this patch. uvLocator.build(this, edge, bindInfo); patchId= uvLocator.selectPatch(stIn); uvLocator.locateUV(stIn, patchId, patchOut, stOut); // Get the Uv, in [0,Order?*NL_LUMEL_BY_TILE] basis (ie lumel basis), and get from neighbor patch sint u, v; u= (sint)floor(stOut.x*NL_LUMEL_BY_TILE); v= (sint)floor(stOut.y*NL_LUMEL_BY_TILE); patchOut->computeTileLightmapPixel(u>>NL_LUMEL_BY_TILE_SHIFT, v>>NL_LUMEL_BY_TILE_SHIFT, u&(NL_LUMEL_BY_TILE-1), v&(NL_LUMEL_BY_TILE-1), dest); } } // else we must still smooth with our lumel on this patch, so get it from neighbor on edge. else { // first, clamp to our patch (recenter on the previous pixel) if(stIn.x<0) stIn.x+= lumelSize; else if(stIn.x>OrderS) stIn.x-= lumelSize; else if(stIn.y<0) stIn.y+= lumelSize; else if(stIn.y>OrderT) stIn.y-= lumelSize; // Get the Uv, in [0,Order?*NL_LUMEL_BY_TILE] basis (ie lumel basis), and get from this patch sint u, v; u= (sint)floor(stIn.x*NL_LUMEL_BY_TILE); v= (sint)floor(stIn.y*NL_LUMEL_BY_TILE); computeTileLightmapPixel(u>>NL_LUMEL_BY_TILE_SHIFT, v>>NL_LUMEL_BY_TILE_SHIFT, u&(NL_LUMEL_BY_TILE-1), v&(NL_LUMEL_BY_TILE-1), dest); } } // else it is on a corner of the patch. else { // if the corner of the patch (same as tile corner) is smoothed, find on neighbor if(getCornerSmoothFlag(corner)) { // retrieve neigbhor info. NB: use edgeId=corner, (corner X is the start of the edge X)it works. getBindNeighbor(corner, bindInfo); // if neighbor present. if(bindInfo.Zone) { // Ok, search uv on this patch. uvLocator.build(this, corner, bindInfo); patchId= uvLocator.selectPatch(stIn); uvLocator.locateUV(stIn, patchId, patchOut, stOut); // same reasoning as in computeDisplaceCornerSmooth(), must find the pixel on the neighbor // of our neighbor. But the current corner may be a corner on a bind X/1. All is managed by doing // this way. patchOut->computeTileLightmapPixelAroundCorner(stOut, dest, true); } } } } } }

void NL3D::CPatch::computeNewFar (  const NLMISC::CBSphere &  patchSphere, sint &  newFar0, sint &  newFar1 )  [private]

Definition at line 54 of file patch_render.cpp. References _PatchRdrPassFar0, _PatchRdrPassFar1, NLMISC::CBSphere::Center, Far0UBias, Far0UScale, Far0VBias, Far0VScale, Far1UBias, Far1UScale, Far1VBias, Far1VScale, NL3D::CLandscape::freeFarRenderPass(), NL3D::CLandscape::getFarRenderPass(), NL3D::CZone::Landscape, NL_PATCH_FAR0_ROTATED, NL_PATCH_FAR1_ROTATED, nlassert, nlstop, OOTransitionSqrDelta, r, NLMISC::CBSphere::Radius, sint, NLMISC::sqr(), TransitionSqrMin, and uint8. Referenced by preRender(), and updateTextureFarOnly(). { // Classify the patch. //======================== float r= (CLandscapeGlobals::RefineCenter-patchSphere.Center).norm() - patchSphere.Radius; float rr=0.0; if(r<CLandscapeGlobals::TileDistNear) rr= r-CLandscapeGlobals::TileDistNear, newFar0= 0; else if(r<CLandscapeGlobals::Far0Dist) rr= r-CLandscapeGlobals::Far0Dist, newFar0= 1; else if(r<CLandscapeGlobals::Far1Dist) rr= r-CLandscapeGlobals::Far1Dist, newFar0= 2; else newFar0= 3; // Transition with the next level. newFar1=0; if(newFar0<3 && rr>-(CLandscapeGlobals::FarTransition+2*patchSphere.Radius)) { newFar1= newFar0+1; } // Update Texture Info. //======================== if(newFar0!=Far0 || newFar1!=Far1) { // Backup old pass0 CPatchRdrPass *oldPass0=_PatchRdrPassFar0; CPatchRdrPass *oldPass1=_PatchRdrPassFar1; // Checks if (oldPass0==NULL) nlassert (Far0<=0); if (oldPass1==NULL) nlassert (Far1<=0); float oldFar0UScale=Far0UScale; float oldFar0VScale=Far0VScale; float oldFar0UBias=Far0UBias; float oldFar0VBias=Far0VBias; uint8 oldFlags=Flags; // Don't delete the pass0 if the new newFar1 will use it if ((newFar1==Far0)&&(Far0>0)) _PatchRdrPassFar0=NULL; // Don't delete the pass1 if the new newFar0 will use it if ((newFar0==Far1)&&(Far1>0)) _PatchRdrPassFar1=NULL; // Pass0 have changed ? if (newFar0!=Far0) { // Compute / get the texture Far. if(newFar0>0) { // Free the old pass, don't used any more if (_PatchRdrPassFar0) Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar0, Far0); // Can we use the old pass1 ? if (newFar0==Far1) { // Yes, recycle it! _PatchRdrPassFar0=oldPass1; // Copy uv coordinates Far0UScale=Far1UScale; Far0VScale=Far1VScale; Far0UBias=Far1UBias; Far0VBias=Far1VBias; // Copy rotation flag Flags&=~NL_PATCH_FAR0_ROTATED; // erase it if (Flags&NL_PATCH_FAR1_ROTATED) Flags|=NL_PATCH_FAR0_ROTATED; // copy it } else // get a new render pass { // Rotation boolean bool bRot; _PatchRdrPassFar0=Zone->Landscape->getFarRenderPass(this, newFar0, Far0UScale, Far0VScale, Far0UBias, Far0VBias, bRot); // Flags is set if the far texture is rotated of 90deg to the left if (bRot) Flags|=NL_PATCH_FAR0_ROTATED; else Flags&=~NL_PATCH_FAR0_ROTATED; } } else // no more far pass0 { if (_PatchRdrPassFar0) { Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar0, Far0); _PatchRdrPassFar0=NULL; } } } // Pass1 have changed ? if (newFar1!=Far1) { // Now let's go with pass1 if(newFar1>0) { // Delete the pass1 if not used any more if (_PatchRdrPassFar1) Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar1, Far1); // Can we use the old pass1 ? if (newFar1==Far0) { // Yes, recycle it! _PatchRdrPassFar1= oldPass0; nlassert (_PatchRdrPassFar1); // Copy uv coordinates Far1UScale=oldFar0UScale; Far1VScale=oldFar0VScale; Far1UBias=oldFar0UBias; Far1VBias=oldFar0VBias; // Copy rotation flag Flags&=~NL_PATCH_FAR1_ROTATED; // erase it if (oldFlags&NL_PATCH_FAR0_ROTATED) Flags|=NL_PATCH_FAR1_ROTATED; // copy it } else // get a new render pass { // Rotation boolean bool bRot; _PatchRdrPassFar1=Zone->Landscape->getFarRenderPass(this, newFar1, Far1UScale, Far1VScale, Far1UBias, Far1VBias, bRot); nlassert (_PatchRdrPassFar1); // Flags is set if the far texture is rotated of 90deg to the left if (bRot) Flags|=NL_PATCH_FAR1_ROTATED; else Flags&=~NL_PATCH_FAR1_ROTATED; } // Compute info for transition. float farDist; switch(newFar1) { case 1: farDist= CLandscapeGlobals::TileDistNear; break; case 2: farDist= CLandscapeGlobals::Far0Dist; break; case 3: farDist= CLandscapeGlobals::Far1Dist; break; default: nlstop; }; TransitionSqrMin= sqr(farDist-CLandscapeGlobals::FarTransition); OOTransitionSqrDelta= 1.0f/(sqr(farDist)-TransitionSqrMin); } else // no more far pass1 { if (_PatchRdrPassFar1) { Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar1, Far1); _PatchRdrPassFar1=NULL; } } } } // Don't copy Far0 and Far1. }

void NL3D::CPatch::computeNoise (  float  s, float  t, CVector &  displace )  const [private]

compute the Final displacement for s,t ([0;1], [0;1]). This is the top call. displace.norm() should be <= NL3D_NOISE_MAX. Definition at line 874 of file patch_noise.cpp. References computeDisplaceCornerSmooth(), computeDisplaceEdgeSmooth(), computeDisplaceInteriorSmooth(), computeNormalCornerSmooth(), computeNormalEdgeSmooth(), NL3D::CBezierPatch::evalNormal(), s, sint8, t, and unpackIntoCache(). Referenced by computeVertex(). { float so= s*OrderS; float to= t*OrderT; // Pre-Compute Border Smothing. //========================= // If we are on a border, flag it. sint8 smoothNormalBorderX= 0; sint8 smoothNormalBorderY= 0; // NB: because OrderS and OrderT >=2, smoothNormalBorderX=-1 and smoothNormalBorderX=1 are exclusive (as smoothNormalBorderY). if(so < 1) smoothNormalBorderX= -1; else if(so > OrderS-1) smoothNormalBorderX= 1; if(to < 1) smoothNormalBorderY= -1; else if(to > OrderT-1) smoothNormalBorderY= 1; bool smoothNormalEdge= (smoothNormalBorderX!=0) != (smoothNormalBorderY!=0); bool smoothNormalCorner= (smoothNormalBorderX!=0) && (smoothNormalBorderY!=0); // Do same thing, but to know if we must compute a displace on an interior, on an edge or on a corner. sint8 smoothDisplaceBorderX= 0; sint8 smoothDisplaceBorderY= 0; // NB: because OrderS and OrderT >=2, smoothBorderX=-1 and smoothBorderX=1 are exclusive (as smoothBorderY). if(so < 0.5) smoothDisplaceBorderX= -1; else if(so > OrderS-0.5) smoothDisplaceBorderX= 1; if(to < 0.5) smoothDisplaceBorderY= -1; else if(to > OrderT-0.5) smoothDisplaceBorderY= 1; bool smoothDisplaceEdge= (smoothDisplaceBorderX!=0) != (smoothDisplaceBorderY!=0); bool smoothDisplaceCorner= (smoothDisplaceBorderX!=0) && (smoothDisplaceBorderY!=0); // Compute Displace value. //========================= float displaceValue; if(smoothDisplaceCorner) displaceValue= computeDisplaceCornerSmooth(so, to, smoothDisplaceBorderX, smoothDisplaceBorderY); else if(smoothDisplaceEdge) displaceValue= computeDisplaceEdgeSmooth(so, to, smoothDisplaceBorderX, smoothDisplaceBorderY); else displaceValue= computeDisplaceInteriorSmooth(so, to); // Compute Displace normal. //========================= // Evaluate the normal. CVector displaceNormal; // smooth on edges and on corners. if(smoothNormalCorner) displaceNormal= computeNormalCornerSmooth(so, to, smoothNormalBorderX, smoothNormalBorderY); else if(smoothNormalEdge) displaceNormal= computeNormalEdgeSmooth(so, to, smoothNormalBorderX, smoothNormalBorderY); else { // unpack... CBezierPatch *bpatch= unpackIntoCache(); // eval. displaceNormal= bpatch->evalNormal(s, t); } // Final result. //========================= displace= displaceNormal * displaceValue; }

CVector NL3D::CPatch::computeNormalCornerSmooth (  float  s, float  t, sint8  smoothBorderX, sint8  smoothBorderY )  const [private]

compute the smoothed normal for s,t ([0;OrderS], [0;OrderT]). Special case on corner. Definition at line 728 of file patch_noise.cpp. References NL3D::CPatchUVLocator::build(), computeNormalEdgeSmooth(), computeNormalOnNeighbor(), NL3D::CPatch::CBindInfo::Edge, NL3D::CBezierPatch::evalNormal(), getBindNeighbor(), getCornerSmoothFlag(), getOrderS(), getOrderT(), NL3D::CPatchUVLocator::locateUV(), nlassert, nlstop, NL3D::noiseCeilF(), NL3D::noiseFloorF(), s, NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint8, t, uint, unpackIntoCache(), NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by computeNoise(). { CBindInfo bindInfoX; CBindInfo bindInfoY; uint edgeX=0; uint edgeY=0; uint corner; CBezierPatch *bpatch; bpatch= unpackIntoCache(); // both must be not null nlassert( (smoothBorderX!=0) && (smoothBorderY!=0) ); // Get the edge against we must share displace. if(smoothBorderX==-1) edgeX=0; else if(smoothBorderX==1) edgeX=2; else nlstop; if(smoothBorderY==1) edgeY=1; else if(smoothBorderY==-1) edgeY=3; else nlstop; // Get the corner against we must share displace. if(smoothBorderX==-1) { if(smoothBorderY==-1) corner=0; else corner=1; } else { if(smoothBorderY==-1) corner=3; else corner=2; } // If this corner is smoothed, blend with 4 neighbors patchs. if(getCornerSmoothFlag(corner)) { // Build the bindInfo against the 2 edge. getBindNeighbor(edgeX, bindInfoX); getBindNeighbor(edgeY, bindInfoY); // Fast reject: if no neighbor, just do a simple computeDisplaceInteriorSmooth. if(!bindInfoX.Zone || !bindInfoY.Zone) return bpatch->evalNormal(s/getOrderS(), t/getOrderT()); else { CVector ret; // Compute the coordinate on the border of the edge, and the coef of the blend. float se=s; float te=t; float coefX; float coefY; if(smoothBorderX==-1) se= noiseFloorF(se), coefX=s-se; else se= noiseCeilF(se), coefX=se-s; if(smoothBorderY==-1) te= noiseFloorF(te), coefY=t-te; else te= noiseCeilF(te), coefY=te-t; coefX= 0.5f + coefX*0.5f; coefY= 0.5f + coefY*0.5f; // Compute our contribution. ret= bpatch->evalNormal(s/getOrderS(), t/getOrderT()) *coefX*coefY; // compute Neighboring info. CPatchUVLocator uvLocatorX; CPatchUVLocator uvLocatorY; CVector2f stIn, stOut; CPatch *patchOut; uint patchId; uvLocatorX.build(this, edgeX, bindInfoX); uvLocatorY.build(this, edgeY, bindInfoY); // Patch on our X side. stIn.set(se, te); patchId= uvLocatorX.selectPatch(stIn); uvLocatorX.locateUV(stIn, patchId, patchOut, stOut); bpatch= patchOut->unpackIntoCache(); ret+= bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT()) *(1-coefX)*coefY; // Patch on our Y side. stIn.set(se, te); patchId= uvLocatorY.selectPatch(stIn); uvLocatorY.locateUV(stIn, patchId, patchOut, stOut); bpatch= patchOut->unpackIntoCache(); ret+= bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT()) *coefX*(1-coefY); /* compute contribution of the patch adjacent to me. Same reasoning as in computeDisplaceCornerSmooth(). */ stIn.set(se, te); patchId= uvLocatorY.selectPatch(stIn); uvLocatorY.locateUV(stIn, patchId, patchOut, stOut); // Because we compute the normal exactly on the edge, we must inform this method not to take us as neighbor. // ugly but simpler. ret+= patchOut->computeNormalOnNeighbor(stOut.x, stOut.y, bindInfoY.Edge[patchId]) *(1-coefX)*(1-coefY); return ret; } } // else must blend with 0. else { // compute coef. float se=s; float te=t; float coefX; float coefY; if(smoothBorderX==-1) se= noiseFloorF(se), coefX=s-se; else se= noiseCeilF(se), coefX=se-s; if(smoothBorderY==-1) te= noiseFloorF(te), coefY=t-te; else te= noiseCeilF(te), coefY=te-t; // To have smooth continuities with smooth on edge (if any), we must do this. CVector rx, ry; // Compute a smooth with my X neighbor. rx= computeNormalEdgeSmooth(s, t, smoothBorderX, 0); // Compute a smooth with my Y neighbor. ry= computeNormalEdgeSmooth(s, t, 0, smoothBorderY); // Blend the 2 result. if(coefY + coefX>0) { // This the weight used to blend to 0. float maxCoef= max(coefY, coefX); // This the weight used to blend beetween rx and ry. float ooSum= 1.0f / (coefY + coefX); float blendCoefX= coefX * ooSum; float blendCoefY= coefY * ooSum; return maxCoef* (rx*blendCoefY + ry*blendCoefX); } else { return CVector::Null; } } }

CVector NL3D::CPatch::computeNormalEdgeSmooth (  float  s, float  t, sint8  smoothBorderX, sint8  smoothBorderY )  const [private]

compute the smoothed normal for s,t ([0;OrderS], [0;OrderT]). Special case on edge. Definition at line 588 of file patch_noise.cpp. References NL3D::CPatchUVLocator::build(), NL3D::CBezierPatch::evalNormal(), getBindNeighbor(), getOrderS(), getOrderT(), getSmoothFlag(), NL3D::CPatchUVLocator::locateUV(), nlassert, nlstop, NL3D::noiseCeilF(), NL3D::noiseFloorF(), s, NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint8, t, uint, unpackIntoCache(), NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by computeNoise(), and computeNormalCornerSmooth(). { CBindInfo bindInfo; uint edge=0; CBezierPatch *bpatch; bpatch= unpackIntoCache(); // only one must be not null nlassert( (smoothBorderX==0) != (smoothBorderY==0) ); // Get the edge against we must share displace. if(smoothBorderX==-1) edge=0; else if(smoothBorderY==1) edge=1; else if(smoothBorderX==1) edge=2; else if(smoothBorderY==-1) edge=3; else nlstop; // If the edge is smoothed, blend with neighbor. if(getSmoothFlag(edge)) { // Build the bindInfo against this edge. getBindNeighbor(edge, bindInfo); // Fast reject: if no neighbor, just do a simple computeDisplaceInteriorSmooth. if(!bindInfo.Zone) return bpatch->evalNormal(s/getOrderS(), t/getOrderT()); else { CVector r0, r1; // Compute our contribution. r0= bpatch->evalNormal(s/getOrderS(), t/getOrderT()); // Compute the coordinate on the border of the edge, and the coef of the blend. float se=s; float te=t; float coef=0.0; if(smoothBorderX==-1) se= noiseFloorF(se), coef=s-se; else if(smoothBorderX==1) se= noiseCeilF(se), coef=se-s; else if(smoothBorderY==-1) te= noiseFloorF(te), coef=t-te; else if(smoothBorderY==1) te= noiseCeilF(te), coef=te-t; coef= 0.5f + coef*0.5f; // Compute contribution of the normal on the neighbor, on the border of the edge. CPatchUVLocator uvLocator; CVector2f stIn, stOut; CPatch *patchOut; uint patchId; uvLocator.build(this, edge, bindInfo); stIn.set(se, te); patchId= uvLocator.selectPatch(stIn); uvLocator.locateUV(stIn, patchId, patchOut, stOut); bpatch= patchOut->unpackIntoCache(); r1= bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT()); // NB: don't bother problems with bind 1/X and the choice of the patch, because bind are C1, so normal is C0. // Blend 2 result. For speed optim, don't normalize. return r0*coef + r1*(1-coef); } } // else blend with vector Null. else { // compute coef. float se=s; float te=t; float coef=0.0; if(smoothBorderX==-1) se= noiseFloorF(se), coef=s-se; else if(smoothBorderX==1) se= noiseCeilF(se), coef=se-s; else if(smoothBorderY==-1) te= noiseFloorF(te), coef=t-te; else if(smoothBorderY==1) te= noiseCeilF(te), coef=te-t; // Compute our contribution. CVector r0; r0= bpatch->evalNormal(s/getOrderS(), t/getOrderT()); // Blend with 0. return r0*coef; } }

CVector NL3D::CPatch::computeNormalOnNeighbor (  float  s, float  t, uint  edgeExclude )  const [private]

same reasoning as in computeDisplaceRawOnNeighbor(). Definition at line 675 of file patch_noise.cpp. References NL3D::CPatchUVLocator::build(), NL3D::CBezierPatch::evalNormal(), getBindNeighbor(), getOrderS(), getOrderT(), NL3D::CPatchUVLocator::locateUV(), s, NL3D::CPatchUVLocator::selectPatch(), NLMISC::CVector2f::set(), sint, t, uint, unpackIntoCache(), NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by computeNormalCornerSmooth(). { sint edge= -1; // look on what neighbor patch we must find the value (if any). if(s<1 && edgeExclude!=0) edge=0; else if(t>OrderT-1 && edgeExclude!=1) edge=1; else if(s>OrderS-1 && edgeExclude!=2) edge=2; else if(t<1 && edgeExclude!=3) edge=3; // If the location is In the patch, just return normal value. (case of a bind 1/X). if(edge==-1) { CBezierPatch *bpatch= unpackIntoCache(); return bpatch->evalNormal(s/getOrderS(), t/getOrderT()); } // else must find on neighbor. else { CBindInfo bindInfo; getBindNeighbor(edge, bindInfo); // Fast reject: if no neighbor on the edge, just do a simple computeDisplaceRaw() if(!bindInfo.Zone) { CBezierPatch *bpatch= unpackIntoCache(); return bpatch->evalNormal(s/getOrderS(), t/getOrderT()); } // else must find on neighbor. else { CPatchUVLocator uvLocator; uvLocator.build(this, edge, bindInfo); CVector2f stIn; CVector2f stOut; CPatch *patchOut; uint patchId; // look on neighbor. same reasoning as in computeDisplaceEdgeSmooth(); stIn.set(s, t); patchId= uvLocator.selectPatch(stIn); uvLocator.locateUV(stIn, patchId, patchOut, stOut); CBezierPatch *bpatch= patchOut->unpackIntoCache(); return bpatch->evalNormal(stOut.x/patchOut->getOrderS(), stOut.y/patchOut->getOrderT()); } } }

void NL3D::CPatch::computeSoftwareGeomorphAndAlpha (   )

Definition at line 1378 of file patch_render.cpp. References computeGeomorphAlphaFar1VertexListVB(), computeGeomorphFar0VertexListVB(), computeGeomorphTileVertexListVB(), computeGeomorphVertexList(), NL3D::CTessBlock::FarVertexList, NL3D::CTessBlock::getClipped(), isRenderClipped(), MasterBlock, NL3D::CTessBlock::NearVertexList, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, NL3D::CTessBlock::visibleFar0(), NL3D::CTessBlock::visibleFar1(), and NL3D::CTessBlock::visibleTile(). Referenced by NL3D::CLandscape::render(). { if(isRenderClipped()) return; // Compute Geomorph. //======= // Need only to fill CTessVertex, so do it only for FarVertices // Hence Geomorph is done twice on edges of patches!!. // If not too near for precise, fast compute of geomorph. if( TessBlocks.size()==0 ) { // Just update all vertices of master block. computeGeomorphVertexList(MasterBlock.FarVertexList); } else { // update all vertices of master block. computeGeomorphVertexList(MasterBlock.FarVertexList); // update vertices of others block. for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // Precise Clip. if(!tblock.getClipped()) { // compute the geomorph of the vertices in the tessblock. computeGeomorphVertexList(tblock.FarVertexList); } } } // Fill Far0. //======= if(Far0>0) { // Fill Far0 VB. computeGeomorphFar0VertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // Precise Clip. if( tblock.visibleFar0() ) computeGeomorphFar0VertexListVB(tblock.FarVertexList); } } else if(Far0==0) { // Fill Tile VB. // No Tiles in MasterBlock!! // Traverse the TessBlocks to compute vertices. for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // Precise Clip. if( tblock.visibleTile() ) computeGeomorphTileVertexListVB(tblock.NearVertexList); } } // Fill Far1. //======= if(Far1>0) { // Fill VB. computeGeomorphAlphaFar1VertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // Precise Clip. if( tblock.visibleFar1() ) computeGeomorphAlphaFar1VertexListVB(tblock.FarVertexList); } } }

void NL3D::CPatch::computeTbTm (  uint &  numtb, uint &  numtm, uint  ts, uint  tt )  [private]

Definition at line 942 of file patch.cpp. References sint, and uint. Referenced by appendNearVertexToRenderList(), appendTileMaterialToRenderList(), getTileLightMap(), getTileLightMapUvInfo(), releaseTileLightMap(), removeNearVertexFromRenderList(), and removeTileMaterialFromRenderList(). { sint is= ts&1; sint it= tt&1; ts>>=1; tt>>=1; numtb= tt*(uint)(OrderS>>1) + ts; numtm= it*2+is; }

void NL3D::CPatch::computeTileLightmap (  uint  ts, uint  tt, NLMISC::CRGBA *  dest, uint  stride )  [private]

Definition at line 750 of file patch_lightmap.cpp. References addTileLightmapWithTLI(), computeTileLightmapAutomatic(), computeTileLightmapPrecomputed(), NL3D::CLandscape::getAutomaticLighting(), getLandscape(), modulateTileLightmapWithTileColors(), stride, and uint. Referenced by computeNearBlockLightmap(). { if(getLandscape()->getAutomaticLighting()) computeTileLightmapAutomatic(ts, tt, dest, stride); else { computeTileLightmapPrecomputed(ts, tt, dest, stride); // Add the inlufence of TLI. addTileLightmapWithTLI(ts, tt, dest, stride); } // modulate dest with tileColors (at center of lumels). modulateTileLightmapWithTileColors(ts, tt, dest, stride); }

void NL3D::CPatch::computeTileLightmapAutomatic (  uint  ts, uint  tt, NLMISC::CRGBA *  dest, uint  stride )  [private]

Definition at line 557 of file patch_lightmap.cpp. References computeTileLightmapPixelAutomatic(), NL_LUMEL_BY_TILE, stride, uint, x, and y. Referenced by computeTileLightmap(). { uint x, y; for(y=0; y<NL_LUMEL_BY_TILE; y++) { for(x=0; x<NL_LUMEL_BY_TILE; x++) { // compute this pixel. computeTileLightmapPixelAutomatic(ts, tt, x, y, dest+ y*stride + x); } } }

void NL3D::CPatch::computeTileLightmapEdge (  uint  ts, uint  tt, uint  edge, NLMISC::CRGBA *  dest, uint  stride, bool  inverse )  [private]

Definition at line 765 of file patch_lightmap.cpp. References addTileLightmapEdgeWithTLI(), computeTileLightmapEdgeAutomatic(), computeTileLightmapEdgePrecomputed(), NL3D::CLandscape::getAutomaticLighting(), getLandscape(), modulateTileLightmapEdgeWithTileColors(), stride, and uint. Referenced by computeNearBlockLightmap(). { if(getLandscape()->getAutomaticLighting()) computeTileLightmapEdgeAutomatic(ts, tt, edge, dest, stride, inverse); else { computeTileLightmapEdgePrecomputed(ts, tt, edge, dest, stride, inverse); // Add the inlufence of TLI. addTileLightmapEdgeWithTLI(ts, tt, edge, dest, stride, inverse); } // modulate dest with tileColors (at center of lumels). modulateTileLightmapEdgeWithTileColors(ts, tt, edge, dest, stride, inverse); }

void NL3D::CPatch::computeTileLightmapEdgeAutomatic (  uint  ts, uint  tt, uint  edge, NLMISC::CRGBA *  dest, uint  stride, bool  inverse )  [private]

Definition at line 571 of file patch_lightmap.cpp. References computeTileLightmapPixelAutomatic(), NL_LUMEL_BY_TILE, stride, uint, x, and y. Referenced by computeTileLightmapEdge(). { // get coordinate according to edge. uint x=0,y=0; switch(edge) { case 0: x= 0; break; case 1: y= NL_LUMEL_BY_TILE-1; break; case 2: x= NL_LUMEL_BY_TILE-1; break; case 3: y= 0; break; }; uint i; for(i=0; i<NL_LUMEL_BY_TILE; i++) { // if vertical edge if( (edge&1)==0 ) y= i; // else horizontal edge else x= i; // manage inverse. uint where; if(inverse) where= (NL_LUMEL_BY_TILE-1)-i; else where= i; // compute this pixel. computeTileLightmapPixelAutomatic(ts, tt, x, y, dest+ where*stride); } }

void NL3D::CPatch::computeTileLightmapEdgePrecomputed (  uint  ts, uint  tt, uint  edge, NLMISC::CRGBA *  dest, uint  stride, bool  inverse )  [private]

Definition at line 704 of file patch_lightmap.cpp. References CompressedLumels, getLandscape(), NL3D::CLandscape::getStaticLight(), NL3D::getUnpackLumelBlock(), NL3D::NL3DDeltaLumel, NL3D::NL3DPixelStartLumel, NL_BLOCK_LUMEL_COMPRESSED_SIZE, src, stride, uint, uint8, and x. Referenced by computeTileLightmapEdge(). { // Lumel table const CRGBA* colorTable=getLandscape ()->getStaticLight (); // Witch corner to start ? uint pixel=NL3DPixelStartLumel[edge]; uint delta=NL3DDeltaLumel[edge]; // For each lumels const uint8 *src=&(CompressedLumels[(ts + (tt*OrderS))*NL_BLOCK_LUMEL_COMPRESSED_SIZE]); uint x; if (inverse) { uint inverseStride=stride*(4-1); for(x=0; x<4; x++) { // lumel dest[inverseStride-x*stride]=colorTable[getUnpackLumelBlock (src, pixel)]; pixel+=delta; } } else { for(x=0; x<4; x++) { // lumel dest[x*stride]=colorTable[getUnpackLumelBlock (src, pixel)]; pixel+=delta; } } }

void NL3D::CPatch::computeTileLightmapPixel (  uint  ts, uint  tt, uint  s, uint  t, NLMISC::CRGBA *  dest )  [private]

Definition at line 782 of file patch_lightmap.cpp. References addTileLightmapPixelWithTLI(), computeTileLightmapPixelAutomatic(), computeTileLightmapPixelPrecomputed(), NL3D::CLandscape::getAutomaticLighting(), getLandscape(), modulateTileLightmapPixelWithTileColors(), s, t, and uint. Referenced by computeNearBlockLightmap(), and computeTileLightmapPixelAroundCorner(). { if(getLandscape()->getAutomaticLighting()) computeTileLightmapPixelAutomatic(ts, tt, s, t, dest); else { computeTileLightmapPixelPrecomputed(ts, tt, s, t, dest); // Add the inlufence of TLI. addTileLightmapPixelWithTLI(ts, tt, s, t, dest); } // modulate dest with tileColors (at center of lumels). modulateTileLightmapPixelWithTileColors(ts, tt, s, t, dest); }

void NL3D::CPatch::computeTileLightmapPixelAroundCorner (  const NLMISC::CVector2f &  stIn, NLMISC::CRGBA *  dest, bool  lookAround )  [private]

Definition at line 799 of file patch_lightmap.cpp. References NL3D::CPatchUVLocator::build(), computeTileLightmapPixel(), getBindNeighbor(), NL3D::CPatchUVLocator::locateUV(), NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE_SHIFT, NL3D::CPatchUVLocator::selectPatch(), sint, uint, v, NLMISC::CVector2f::x, NLMISC::CVector2f::y, and NL3D::CPatch::CBindInfo::Zone. Referenced by computeNearBlockLightmap(). { bool mustLookOnNeighbor= false; // Get the Uv, in [0,Order?*NL_LUMEL_BY_TILE] basis (ie lumel basis). sint u, v; u= (sint)floor(stIn.x*NL_LUMEL_BY_TILE); v= (sint)floor(stIn.y*NL_LUMEL_BY_TILE); // if allowed, try to go on neighbor patch. if(lookAround) { // try to know if we must go on a neighbor patch (maybe false with bind X/1). if( u<0 || u>=OrderS*NL_LUMEL_BY_TILE || v<0 || v>=OrderT*NL_LUMEL_BY_TILE) mustLookOnNeighbor= true; } // If we must get (if possible) the pixel in the current patch, do it. if(!mustLookOnNeighbor) { // if out this patch, abort. if( u<0 || u>=OrderS*NL_LUMEL_BY_TILE || v<0 || v>=OrderT*NL_LUMEL_BY_TILE) return; else { // get this pixel. computeTileLightmapPixel(u>>NL_LUMEL_BY_TILE_SHIFT, v>>NL_LUMEL_BY_TILE_SHIFT, u&(NL_LUMEL_BY_TILE-1), v&(NL_LUMEL_BY_TILE-1), dest); } } // else get from the best neighbor patch. else { // choose against which edge we must find the pixel. uint edge=0; if(u<0) edge=0; else if(v>=OrderT*NL_LUMEL_BY_TILE) edge=1; else if(u>=OrderS*NL_LUMEL_BY_TILE) edge=2; else if(v<0) edge=3; // retrieve info on neighbor. CBindInfo bindInfo; getBindNeighbor(edge, bindInfo); // if neighbor present. if(bindInfo.Zone) { CVector2f stOut; CPatch *patchOut; uint patchId; // Ok, search uv on this patch. CPatchUVLocator uvLocator; uvLocator.build(this, edge, bindInfo); patchId= uvLocator.selectPatch(stIn); uvLocator.locateUV(stIn, patchId, patchOut, stOut); // retry only one time, so at next call, must find the data IN htis patch (else abort). patchOut->computeTileLightmapPixelAroundCorner(stOut, dest, false); } } }

void NL3D::CPatch::computeTileLightmapPixelAutomatic (  uint  ts, uint  tt, uint  s, uint  t, NLMISC::CRGBA *  dest )  [private]

Definition at line 601 of file patch_lightmap.cpp. References NLMISC::clamp(), computeVertex(), NL3D::CLandscape::getAutomaticLightDir(), getLandscape(), NL3D::CLandscape::getStaticLight(), NL_LUMEL_BY_TILE, NLMISC::CVector::normalize(), s, sint, t, uint, and v. Referenced by computeTileLightmapAutomatic(), computeTileLightmapEdgeAutomatic(), and computeTileLightmapPixel(). { float u,v; static const float lumelSize= 1.f/NL_LUMEL_BY_TILE; // use 3 computeVertex to compute a normal. This is slow.... CVector p0, p1 ,p2; // 1st vert. Top-left of the lumel. u= (ts + s*lumelSize )/OrderS; v= (tt + t*lumelSize )/OrderT; p0= computeVertex(u, v); // 2nd vert. Bottom-left of the lumel. u= (ts + s*lumelSize )/OrderS; v= (tt + (t+1)*lumelSize )/OrderT; p1= computeVertex(u, v); // 3rd vert. Center-Right of the lumel. u= (ts + (s+1)*lumelSize )/OrderS; v= (tt + (t+0.5f)*lumelSize )/OrderT; p2= computeVertex(u, v); // the normal. CVector normal; normal= (p1-p0)^(p2-p0); normal.normalize(); // lighting. float c= -normal*getLandscape()->getAutomaticLightDir(); c= max(c, 0.f); sint ic; #ifdef NL_OS_WINDOWS // FastFloor using fistp. Don't care convention. float fc= c*256; _asm { fld fc fistp ic } #else ic= (sint)floor(c*256); #endif clamp(ic, 0, 255); // ambiant/diffuse lighting. *dest= getLandscape()->getStaticLight()[ic]; }

void NL3D::CPatch::computeTileLightmapPixelPrecomputed (  uint  ts, uint  tt, uint  s, uint  t, NLMISC::CRGBA *  dest )  [private]

Definition at line 738 of file patch_lightmap.cpp. References CompressedLumels, getLandscape(), NL3D::CLandscape::getStaticLight(), NL3D::getUnpackLumelBlock(), NL_BLOCK_LUMEL_COMPRESSED_SIZE, s, t, and uint. Referenced by computeTileLightmapPixel(). { // Lumel table const CRGBA* colorTable=getLandscape ()->getStaticLight (); // Return the lumel *dest=colorTable[getUnpackLumelBlock (&(CompressedLumels[(ts + (tt*OrderS))*NL_BLOCK_LUMEL_COMPRESSED_SIZE]), s+(t<<2))]; }

void NL3D::CPatch::computeTileLightmapPrecomputed (  uint  ts, uint  tt, NLMISC::CRGBA *  dest, uint  stride )  [private]

Definition at line 678 of file patch_lightmap.cpp. References buffer, CompressedLumels, getLandscape(), NL3D::CLandscape::getStaticLight(), NL_BLOCK_LUMEL_COMPRESSED_SIZE, NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE_SHIFT, stride, uint, uint8, unpackLumelBlock(), x, and y. Referenced by computeTileLightmap(). { // Lumel table const CRGBA* colorTable=getLandscape ()->getStaticLight (); // Unpack the lumels uint8 buffer[NL_LUMEL_BY_TILE*NL_LUMEL_BY_TILE]; unpackLumelBlock (buffer, &(CompressedLumels[(ts + (tt*OrderS))*NL_BLOCK_LUMEL_COMPRESSED_SIZE])); // Retrun it uint x, y; for(y=0; y<NL_LUMEL_BY_TILE; y++) { for(x=0; x<NL_LUMEL_BY_TILE; x++) { // lumel dest[y*stride + x]=colorTable[buffer[x+(y<<NL_LUMEL_BY_TILE_SHIFT)]]; } } }

CVector NL3D::CPatch::computeVertex (  float  s, float  t )  const

Compute a vertex. Compute a vertex according to: s,t patch control points uncompressed with zone Bias/Scale. Patch UV geometric correction. Patch noise (and noise of Patch neighbor). Definition at line 1338 of file patch.cpp. References computeNoise(), NL3D::CBezierPatch::eval(), getLandscape(), NL3D::CLandscape::getNoiseMode(), s, t, and unpackIntoCache(). Referenced by addTileTrianglesInBBox(), NL3D::CTessFace::averageTesselationVertices(), averageTesselationVertices(), bind(), NL3D::CLandscape::buildCollideFaces(), computeContinousVertex(), computeTileLightmapPixelAutomatic(), computeVertexButCorner(), NL3D::CLandscapeVegetableBlockCreateContext::eval(), makeRoots(), NL3D::CZoneLighter::processZonePointLightRT(), NL3D::CTessFace::refreshTesselationGeometry(), refreshTesselationGeometry(), NL3D::CTessFace::split(), and NL3D::CTessFace::splitRectangular(). { // \todo yoyo: TODO_UVCORRECT: use UV correction. if(getLandscape()->getNoiseMode()) { // compute displacement map to disturb result. CVector displace; computeNoise(s,t, displace); // return patch(s,t) + dispalcement result. // unpack. Do it after computeNoise(), because this last may change the cache. CBezierPatch *patch= unpackIntoCache(); return patch->eval(s,t) + displace; } else { // unpack and return patch(s,t). CBezierPatch *patch= unpackIntoCache(); return patch->eval(s,t); } }

CVector NL3D::CPatch::computeVertexButCorner (  float  s, float  t, bool &  onCorner )  const [private]

Used by computeContinousVertex(). Definition at line 1456 of file patch.cpp. References BaseVertices, computeVertex(), NL3D::CTessVertex::EndPos, nlassert, nlstop, s, sint, and t. Referenced by computeContinousVertex(). { // must be compiled nlassert(Zone); // Test is on a edge/corner of the patch sint edgeIdS= -1; sint edgeIdT= -1; if(s==0) edgeIdS= 0; else if(s==1) edgeIdS= 2; if(t==0) edgeIdT= 3; else if(t==1) edgeIdT= 1; // test if on a corner if(edgeIdS>=0 && edgeIdT>=0) { // indicate that yes, we are on a corner onCorner= true; // return the baseVertex according to edge falgs if(edgeIdS==0 && edgeIdT==3) return BaseVertices[0]->EndPos; if(edgeIdS==0 && edgeIdT==1) return BaseVertices[1]->EndPos; if(edgeIdS==2 && edgeIdT==1) return BaseVertices[2]->EndPos; if(edgeIdS==2 && edgeIdT==3) return BaseVertices[3]->EndPos; nlstop; // Error, but Avoid warning return CVector::Null; } // else, std case else { onCorner= false; return computeVertex(s, t); } }

void NL3D::CPatch::copyTileFlagsFromPatch (  const CPatch *  src  )

Set this patch flags from an other one. The patchs must match Definition at line 2245 of file patch.cpp. References nlassert, src, Tiles, and uint. Referenced by NL3D::CZone::copyTilesFlags(). { nlassert(OrderS == src->OrderS && OrderT == src->OrderT); for (uint k = 0; k < Tiles.size(); ++k) { Tiles[k].copyFlagsFromOther(src->Tiles[k]); } }

CRGBA NL3D::CPatch::CPatch::getCurrentTLIColor (  uint  x, uint  y )  const [private]

void NL3D::CPatch::createFaceVectorFar0OrTile (   )  [private]

Definition at line 663 of file patch_render.cpp. References NL3D::CTessBlock::createFaceVectorFar0(), getLandscape(), MasterBlock, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by allocateVBAndFaceVector(). { // If Far Mode. if(Far0>0) { // Create the face for all TessBlocks. MasterBlock.createFaceVectorFar0(getLandscape()->_FaceVectorManager); for(uint i=0; i<TessBlocks.size(); i++) TessBlocks[i].createFaceVectorFar0(getLandscape()->_FaceVectorManager); } // Or If Tile Mode. else if(Far0==0) { // Create the face for all TessBlocks. // No tiles in MasterBlock! for(uint i=0; i<TessBlocks.size(); i++) TessBlocks[i].createFaceVectorTile(getLandscape()->_FaceVectorManager); } }

void NL3D::CPatch::createFaceVectorFar1 (   )  [private]

Definition at line 641 of file patch_render.cpp. References NL3D::CTessBlock::createFaceVectorFar1(), getLandscape(), MasterBlock, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by allocateVBAndFaceVector(), and allocateVBAndFaceVectorFar1Only(). { if(Far1>0) { // Create the face for all TessBlocks. MasterBlock.createFaceVectorFar1(getLandscape()->_FaceVectorManager); for(uint i=0; i<TessBlocks.size(); i++) TessBlocks[i].createFaceVectorFar1(getLandscape()->_FaceVectorManager); } }

void NL3D::CPatch::createVegetableBlock (  uint  numTb, uint  ts, uint  tt )  [private]

Create / init the vegetableBlock in the corresponding TessBlock. TessBlocks must exist. Definition at line 294 of file patch_vegetable.cpp. References NL3D::CBezierPatch::eval(), getLandscape(), NL3D::CLandscapeVegetableBlock::init(), NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK, NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT, TessBlocks, uint, unpackIntoCache(), and VegetableClipBlocks. Referenced by appendTileMaterialToRenderList(), and recreateAllVegetableIgs(). { // TessBlock width uint tbWidth= OrderS >> 1; // clipBlock width uint nTbPerCb= NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK; uint cbWidth= (tbWidth + nTbPerCb-1) >> NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT; // compute tessBlock coordinate. uint tbs ,tbt; tbs= ts >> 1; tbt= tt >> 1; // compute clipBlock coordinate. uint cbs,cbt; cbs= tbs >> NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT; cbt= tbt >> NL3D_PATCH_VEGETABLE_NUM_TESSBLOCK_PER_CLIPBLOCK_SHIFT; // create the vegetable block. CLandscapeVegetableBlock *vegetBlock= new CLandscapeVegetableBlock; // Init / append to list. // compute center of the vegetableBlock (approx). CBezierPatch *bpatch= unpackIntoCache(); CVector center= bpatch->eval( (float)(tbs*2+1)/OrderS, (float)(tbt*2+1)/OrderT ); // Lower-Left tile is (tbs*2, tbt*2) vegetBlock->init(center, getLandscape()->_VegetableManager, VegetableClipBlocks[cbt *cbWidth + cbs], this, tbs*2, tbt*2, getLandscape()->_VegetableBlockList); // set in the tessBlock TessBlocks[numTb].VegetableBlock= vegetBlock; }

void NL3D::CPatch::debugAllocationMarkIndices (  uint  marker  )

Definition at line 914 of file patch_render.cpp. References debugAllocationMarkIndicesFarList(), debugAllocationMarkIndicesNearList(), NL3D::CTessBlock::FarVertexList, MasterBlock, NL3D::CTessBlock::NearVertexList, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. { sint i; // Do it For Far. debugAllocationMarkIndicesFarList(MasterBlock.FarVertexList, marker); for(i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; debugAllocationMarkIndicesFarList(tblock.FarVertexList, marker); } // Do it For Near. // No Tiles in MasterBlock!! for(i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; debugAllocationMarkIndicesNearList(tblock.NearVertexList, marker); } }

void NL3D::CPatch::debugAllocationMarkIndicesFarList (  CTessList< CTessFarVertex > &  vertList, uint  marker )  [private]

Definition at line 893 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessFarVertex::Index0, NL3D::CTessFarVertex::Index1, NL3D::CTessNodeList::Next, and uint. Referenced by debugAllocationMarkIndices(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { pVert->Index0= marker; pVert->Index1= marker; } }

void NL3D::CPatch::debugAllocationMarkIndicesNearList (  CTessList< CTessNearVertex > &  vertList, uint  marker )  [private]

Definition at line 904 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessNearVertex::Index, NL3D::CTessNodeList::Next, and uint. Referenced by debugAllocationMarkIndices(). { // Traverse the vertList. CTessNearVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next) { pVert->Index= marker; } }

void NL3D::CPatch::decRefDLMContext (  uint  count = 1  )  [private]

Dec a ref count to the DLMContext, deleting it if refCount== 0. Definition at line 1977 of file patch_lightmap.cpp. References _DLMContext, _DLMContextRefCount, count, fillVBFarsDLMUvOnly(), isRenderClipped(), nlassert, and uint. Referenced by endDLMLighting(), and removeTileMaterialFromRenderList(). { // the patch must be compiled. nlassert(Zone); nlassert(_DLMContextRefCount>0); // dec Ref. _DLMContextRefCount-= count; nlassert(_DLMContextRefCount>=0); // If 0, delete the context. if(_DLMContextRefCount==0) { delete _DLMContext; _DLMContext= NULL; // If the patch is visible, it may have Far Vertices created, // hence, we must reset their DLM Uvs (to point to black pixel) if(!isRenderClipped()) { // setup DLM Uv with new _DLMContext fillVBFarsDLMUvOnly(); } } }

void NL3D::CPatch::decRefTessBlocks (   )  [private]

Definition at line 658 of file patch.cpp. References clearTessBlocks(), nlassert, and TessBlockRefCount. Referenced by removeFaceFromRenderList(), removeFarVertexFromRenderList(), removeNearVertexFromRenderList(), and removeTileMaterialFromRenderList(). { TessBlockRefCount--; // If no loinger need the tessblocks, delete them. if(TessBlockRefCount==0) clearTessBlocks(); nlassert(TessBlockRefCount>=0); }

void NL3D::CPatch::deleteAllVegetableIgs (   )

Delete any vegetable Ig still existing in this patch. Definition at line 282 of file patch_vegetable.cpp. References releaseVegetableBlock(), NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by clearTessBlocks(), and NL3D::CLandscape::enableVegetable(). { // For all TessBlocks, try to release their VegetableBlock for(uint i=0; i<TessBlocks.size(); i++) { releaseVegetableBlock(i); } }

void NL3D::CPatch::deleteFaceVectorFar0OrTile (   )  [private]

Definition at line 683 of file patch_render.cpp. References NL3D::CTessBlock::deleteFaceVectorFar0(), getLandscape(), MasterBlock, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by deleteVBAndFaceVector(). { // If Far Mode. if(Far0>0) { // delete the face for all TessBlocks. MasterBlock.deleteFaceVectorFar0(getLandscape()->_FaceVectorManager); for(uint i=0; i<TessBlocks.size(); i++) TessBlocks[i].deleteFaceVectorFar0(getLandscape()->_FaceVectorManager); } // Or If Tile Mode. else if(Far0==0) { // delete the face for all TessBlocks. // No tiles in MasterBlock! for(uint i=0; i<TessBlocks.size(); i++) TessBlocks[i].deleteFaceVectorTile(getLandscape()->_FaceVectorManager); } }

void NL3D::CPatch::deleteFaceVectorFar1 (   )  [private]

Definition at line 652 of file patch_render.cpp. References NL3D::CTessBlock::deleteFaceVectorFar1(), getLandscape(), MasterBlock, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by deleteVBAndFaceVector(), and deleteVBAndFaceVectorFar1Only(). { if(Far1>0) { // delete the face for all TessBlocks. MasterBlock.deleteFaceVectorFar1(getLandscape()->_FaceVectorManager); for(uint i=0; i<TessBlocks.size(); i++) TessBlocks[i].deleteFaceVectorFar1(getLandscape()->_FaceVectorManager); } }

void NL3D::CPatch::deleteTileUvs (   )

Definition at line 2142 of file patch.cpp. References NL3D::CTessFace::deleteTileUvs(), Son0, and Son1. { Son0->deleteTileUvs(); Son1->deleteTileUvs(); }

void NL3D::CPatch::deleteVBAndFaceVector (   )

Definition at line 837 of file patch_render.cpp. References deleteFaceVectorFar0OrTile(), deleteFaceVectorFar1(), and updateVBAlloc(). Referenced by preRender(), release(), and updateClipPatchVB(). { updateVBAlloc(false); deleteFaceVectorFar1(); deleteFaceVectorFar0OrTile(); }

void NL3D::CPatch::deleteVBAndFaceVectorFar1Only (   )

Definition at line 854 of file patch_render.cpp. References deleteFaceVectorFar1(), NL3D::CTessBlock::FarVertexList, MasterBlock, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, updateFar1VBAlloc(), and NL3D::CTessBlock::visibleFar1(). Referenced by preRender(). { if(Far1>0) { // alloc VB. updateFar1VBAlloc(MasterBlock.FarVertexList, false); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // need update VB only if tessBlock is visible. if( tblock.visibleFar1() ) updateFar1VBAlloc(tblock.FarVertexList, false); } } deleteFaceVectorFar1(); }

void NL3D::CPatch::dirtTessBlockFaceVector (  CTessBlock &  block  )  [private]

Definition at line 783 of file patch.cpp. References NL3D::CTessBlock::appendToModifyListAndDeleteFaceVector(), getLandscape(), NL3D::CTessBlock::isInModifyList(), and isRenderClipped(). Referenced by appendFaceToRenderList(), appendFaceToTileRenderList(), removeFaceFromRenderList(), and removeFaceFromTileRenderList(). { // If patch is visible, block's faceVector should exist, but are no more valid. if(!isRenderClipped()) { // If this tessBlock not already notified to modification. if(!tb.isInModifyList()) { // Then append, and delete all FaceVector. // NB: delete FaceVector now, because the TessBlock himself may disapear soon. tb.appendToModifyListAndDeleteFaceVector(getLandscape()->_TessBlockModificationRoot, getLandscape()->_FaceVectorManager); } } }

void NL3D::CPatch::endDLMLighting (   )

end Dynamic light Process, deleting the DLMContext if necessary. NB: _DLMContext->compileLighting() is not called, since done during render phase. Called by CLandscape. _DLMContext must exist Definition at line 2035 of file patch_lightmap.cpp. References _DLMContext, decRefDLMContext(), nlassert, and NL3D::CPatchDLMContext::OldPointLightCount. Referenced by NL3D::CLandscape::computeDynamicLighting(). { nlassert(_DLMContext); // delete reference from old pointLight influences, at prec render() pass. _DLMContext may be deleted here, // if no more lights use it, and if the patch is not in Near. decRefDLMContext(_DLMContext->OldPointLightCount); }

uint NL3D::CPatch::evalLumelBlock (  const uint8 *  original, const uint8 *  unCompressed, uint  width, uint  height )  [private]

Eval an uncompressed 4x4 block against the original See also: packShadowMap(), unpackShadowMap() Definition at line 244 of file patch_lightmap.cpp. References height, sint, uint, uint8, v, and width. Referenced by packShadowMap(). { // Sum uint sum=0; // Eval error for each.. for (uint v=0; v<height; v++) for (uint u=0; u<width; u++) { sum += abs((sint)original[v*4+u]-(sint)unCompressed[v*4+u]); } // return the sum return sum; }

void NL3D::CPatch::extendTessBlockWithEndPos (  CTessFace *  face  )  [private]

Definition at line 766 of file patch.cpp. References NL3D::CTessVertex::EndPos, getNumTessBlock(), NL3D::CTessFace::Level, TessBlockLimitLevel, TessBlocks, uint, NL3D::CTessFace::VBase, NL3D::CTessFace::VLeft, and NL3D::CTessFace::VRight. Referenced by NL3D::CTessFace::refreshTesselationGeometry(). { if(face->Level>=TessBlockLimitLevel) { // get the tessBlock of the face. uint numtb= getNumTessBlock(face); // Must enlarge the BSphere of the tesblock!! TessBlocks[numtb].extendSphereFirst(face->VBase->EndPos); TessBlocks[numtb].extendSphereAdd(face->VLeft->EndPos); TessBlocks[numtb].extendSphereAdd(face->VRight->EndPos); TessBlocks[numtb].extendSphereCompile(); } }

void NL3D::CPatch::fillFar0DLMUvOnlyVertexListVB (  CTessList< CTessFarVertex > &  vertList  )

Definition at line 1609 of file patch_render.cpp. References _DLMContext, NL3D::CTessList< T >::begin(), NL3D::CPatchDLMContext::DLMUBias, NL3D::CPatchDLMContext::DLMUScale, NL3D::CPatchDLMContext::DLMVBias, NL3D::CPatchDLMContext::DLMVScale, NL3D::CParamCoord::getS(), NL3D::CParamCoord::getT(), NL3D::CTessFarVertex::Index0, NL3D::CTessNodeList::Next, nlassert, NL3D::CTessFarVertex::PCoord, NLMISC::CUV::U, uint8, and NLMISC::CUV::V. Referenced by fillVBFarsDLMUvOnly(). { // The Buffers must have been locked nlassert(CLandscapeGlobals::CurrentFar0VBAllocator); nlassert(CLandscapeGlobals::CurrentFar0VBAllocator->bufferLocked()); // VBInfo must be OK. nlassert(!CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs()); static uint8 *CurVBPtr; static CUV uvDLM; // If the DLMContext exist if(_DLMContext) { // Traverse the vertList, to compute new uvDLM CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize; // compute Uvs. CParamCoord pc= pVert->PCoord; // compute Dynamic lightmap Uv with DLM context info. uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias; uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias; // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change). *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM; } } // else, reset all Uvs else { // just set UV so the vertex point to a black pixel (see CTextureDLM). uvDLM.U= 1; uvDLM.V= 1; // Traverse the vertList, to reset uv CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize; // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change). *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM; } } }

void NL3D::CPatch::fillFar0VertexListVB (  CTessList< CTessFarVertex > &  vertList  )  [private]

Definition at line 1161 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), fillFar0VertexVB(), and NL3D::CTessNodeList::Next. Referenced by fillVB(), fillVBFar0Only(), and preRender(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { fillFar0VertexVB(pVert); } }

void NL3D::CPatch::fillFar0VertexVB (  CTessFarVertex *  pVert  )  [inline, private]

Definition at line 946 of file patch_render.cpp. References _DLMContext, NL3D::CPatchDLMContext::DLMUBias, NL3D::CPatchDLMContext::DLMUScale, NL3D::CPatchDLMContext::DLMVBias, NL3D::CPatchDLMContext::DLMVScale, NL3D::CTessVertex::EndPos, Far0UBias, Far0UScale, Far0VBias, Far0VScale, NL3D::CParamCoord::getS(), NL3D::CParamCoord::getT(), NL3D::CTessFarVertex::Index0, NL3D::CTessVertex::MaxFaceSize, NL3D::CTessVertex::MaxNearLimit, NL_PATCH_FAR0_ROTATED, nlassert, NL3D::CTessFarVertex::PCoord, NL3D::CTessVertex::Pos, NL3D::CTessFarVertex::Src, NL3D::CTessVertex::StartPos, NLMISC::CUV::U, uint8, and NLMISC::CUV::V. Referenced by checkFillVertexVBFar(), and fillFar0VertexListVB(). { // The Buffers must have been locked nlassert(CLandscapeGlobals::CurrentFar0VBAllocator); nlassert(CLandscapeGlobals::CurrentFar0VBAllocator->bufferLocked()); // VBInfo must be OK. nlassert(!CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs()); static uint8 *CurVBPtr; // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar0VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index0 * CLandscapeGlobals::CurrentFar0VBInfo.VertexSize; // NB: the filling order of data is important, for AGP write combiners. // compute Uvs. static CUV uv; CParamCoord pc= pVert->PCoord; if (Flags&NL_PATCH_FAR0_ROTATED) { uv.U= pc.getT()* Far0UScale + Far0UBias; uv.V= (1.f-pc.getS())* Far0VScale + Far0VBias; } else { uv.U= pc.getS()* Far0UScale + Far0UBias; uv.V= pc.getT()* Far0VScale + Far0VBias; } // compute Dynamic lightmap Uv. static CUV uvDLM; if(_DLMContext) // (NB: Suppose BTB kill this test). { // compute UV with DLM context info. uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias; uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias; } else { // just set UV so the vertex point to a black pixel (see CTextureDLM). uvDLM.U= 1; uvDLM.V= 1; } // If not VertexProgram (NB: Suppose BTB kill this test). if( !CLandscapeGlobals::VertexProgramEnabled ) { // Set Pos. Set it local to the current center of landscape *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition; // Set Uvs. *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff0)= uv; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM; } else { // Else must setup Vertex program inputs // v[0]== StartPos. *(CVector*)CurVBPtr= pVert->Src->StartPos; // v[8]== Tex0 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff0)= uv; // v[9]== Tex1 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.TexCoordOff1)= uvDLM; // v[10]== GeomInfo. static CUV geomInfo; geomInfo.U= pVert->Src->MaxFaceSize * CLandscapeGlobals::OORefineThreshold; geomInfo.V= pVert->Src->MaxNearLimit; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.GeomInfoOff)= geomInfo; // v[11]== EndPos - StartPos *(CVector*)(CurVBPtr + CLandscapeGlobals::CurrentFar0VBInfo.DeltaPosOff)= pVert->Src->EndPos - pVert->Src->StartPos; } }

void NL3D::CPatch::fillFar1DLMUvOnlyVertexListVB (  CTessList< CTessFarVertex > &  vertList  )

Definition at line 1664 of file patch_render.cpp. References _DLMContext, NL3D::CTessList< T >::begin(), NL3D::CPatchDLMContext::DLMUBias, NL3D::CPatchDLMContext::DLMUScale, NL3D::CPatchDLMContext::DLMVBias, NL3D::CPatchDLMContext::DLMVScale, NL3D::CParamCoord::getS(), NL3D::CParamCoord::getT(), NL3D::CTessFarVertex::Index1, NL3D::CTessNodeList::Next, nlassert, NL3D::CTessFarVertex::PCoord, NLMISC::CUV::U, uint8, and NLMISC::CUV::V. Referenced by fillVBFarsDLMUvOnly(). { // The Buffers must have been locked nlassert(CLandscapeGlobals::CurrentFar1VBAllocator); nlassert(CLandscapeGlobals::CurrentFar1VBAllocator->bufferLocked()); // VBInfo must be OK. nlassert(!CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs()); static uint8 *CurVBPtr; static CUV uvDLM; // If the DLMContext exist if(_DLMContext) { // Traverse the vertList, to compute new uvDLM CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize; // compute Uvs. CParamCoord pc= pVert->PCoord; // compute Dynamic lightmap Uv with DLM context info. uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias; uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias; // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change). *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM; } } // else, reset all Uvs else { // just set UV so the vertex point to a black pixel (see CTextureDLM). uvDLM.U= 1; uvDLM.V= 1; // Traverse the vertList, to reset uv CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize; // Set Uv DLM only (NB: same code for VertexProgram or not, only TexCoordOff1 may change). *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM; } } }

void NL3D::CPatch::fillFar1VertexListVB (  CTessList< CTessFarVertex > &  vertList  )  [private]

Definition at line 1173 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), fillFar1VertexVB(), and NL3D::CTessNodeList::Next. Referenced by fillVB(), fillVBFar1Only(), and preRender(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { fillFar1VertexVB(pVert); } }

void NL3D::CPatch::fillFar1VertexVB (  CTessFarVertex *  pVert  )  [inline, private]

Definition at line 1022 of file patch_render.cpp. References _DLMContext, NL3D::CPatchDLMContext::DLMUBias, NL3D::CPatchDLMContext::DLMUScale, NL3D::CPatchDLMContext::DLMVBias, NL3D::CPatchDLMContext::DLMVScale, NL3D::CTessVertex::EndPos, Far1UBias, Far1UScale, Far1VBias, Far1VScale, NL3D::CParamCoord::getS(), NL3D::CParamCoord::getT(), NL3D::CTessFarVertex::Index1, NL3D::CTessVertex::MaxFaceSize, NL3D::CTessVertex::MaxNearLimit, NL_PATCH_FAR1_ROTATED, nlassert, OOTransitionSqrDelta, NL3D::CTessFarVertex::PCoord, NL3D::CTessVertex::Pos, NL3D::CTessFarVertex::Src, NL3D::CTessVertex::StartPos, TransitionSqrMin, NLMISC::CUV::U, uint8, and NLMISC::CUV::V. Referenced by checkFillVertexVBFar(), and fillFar1VertexListVB(). { // The Buffers must have been locked nlassert(CLandscapeGlobals::CurrentFar1VBAllocator); nlassert(CLandscapeGlobals::CurrentFar1VBAllocator->bufferLocked()); // VBInfo must be OK. nlassert(!CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs()); static uint8 *CurVBPtr; // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentFar1VBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index1 * CLandscapeGlobals::CurrentFar1VBInfo.VertexSize; // NB: the filling order of data is important, for AGP write combiners. // compute Uvs. static CUV uv; CParamCoord pc= pVert->PCoord; if (Flags&NL_PATCH_FAR1_ROTATED) { uv.U= pc.getT()* Far1UScale + Far1UBias; uv.V= (1.f-pc.getS())* Far1VScale + Far1VBias; } else { uv.U= pc.getS()* Far1UScale + Far1UBias; uv.V= pc.getT()* Far1VScale + Far1VBias; } // compute Dynamic lightmap Uv. static CUV uvDLM; if(_DLMContext) // (NB: Suppose BTB kill this test). { // compute UV with DLM context info. uvDLM.U= pc.getS()* _DLMContext->DLMUScale + _DLMContext->DLMUBias; uvDLM.V= pc.getT()* _DLMContext->DLMVScale + _DLMContext->DLMVBias; } else { // just set UV so the vertex point to a black pixel (see CTextureDLM). uvDLM.U= 1; uvDLM.V= 1; } // If not VertexProgram (NB: Suppose BTB kill this test). if( !CLandscapeGlobals::VertexProgramEnabled ) { // Set Pos. Set it local to the current center of landscape *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition; // Set Uvs. *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff0)= uv; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM; // Set default color. static CRGBA col(255,255,255,255); *(CRGBA*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.ColorOff)= col; } else { // Else must setup Vertex program inputs // v[0]== StartPos. *(CVector*)CurVBPtr= pVert->Src->StartPos; // v[8]== Tex0 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff0)= uv; // v[9]== Tex1 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.TexCoordOff1)= uvDLM; // v[10]== GeomInfo. static CUV geomInfo; geomInfo.U= pVert->Src->MaxFaceSize * CLandscapeGlobals::OORefineThreshold; geomInfo.V= pVert->Src->MaxNearLimit; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.GeomInfoOff)= geomInfo; // v[11]== EndPos - StartPos *(CVector*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.DeltaPosOff)= pVert->Src->EndPos - pVert->Src->StartPos; // v[12]== Alpha information // Hopefully, fillVBFar1Only() is called each Time the Far1 change, in preRender(). // So TransitionSqrMin and OOTransitionSqrDelta in CPath are valid. geomInfo.U= TransitionSqrMin; geomInfo.V= OOTransitionSqrDelta; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentFar1VBInfo.AlphaInfoOff)= geomInfo; } }

void NL3D::CPatch::fillPatchQuadBlock (  CPatchQuadBlock &  quadBlock  )  const

Fill a CPatchQuadBlock, from its required PatchId. nlassert(PatchId size is less than NL_PATCH_BLOCK_MAX_QUAD) Definition at line 460 of file patch.cpp. References NL_PATCH_BLOCK_MAX_QUAD, NL_PATCH_BLOCK_MAX_VERTEX, nlassert, NL3D::CPatchBlockIdent::OrderS, NL3D::CPatchBlockIdent::OrderT, NL3D::CPatchBlockIdent::S0, NL3D::CPatchBlockIdent::S1, NL3D::CPatchBlockIdent::T0, NL3D::CPatchBlockIdent::T1, and uint. Referenced by NL3D::CLandscape::fillPatchQuadBlock(). { CPatchBlockIdent &pbId= quadBlock.PatchBlockId; uint lenS= pbId.S1-pbId.S0; uint lenT= pbId.T1-pbId.T0; nlassert( pbId.OrderS==OrderS ); nlassert( pbId.OrderT==OrderT ); nlassert( pbId.S1<=OrderS ); nlassert( pbId.T1<=OrderT ); nlassert( pbId.S0<pbId.S1 ); nlassert( pbId.T0<pbId.T1 ); nlassert( lenS<=NL_PATCH_BLOCK_MAX_QUAD ); nlassert( lenT<=NL_PATCH_BLOCK_MAX_QUAD ); // Fill vertices. uint s0= pbId.S0; uint t0= pbId.T0; // some preca. float startS0= (float)s0 / (float)(OrderS); float startT0= (float)t0 / (float)(OrderT); float ds= 1.0f/(float)(OrderS); float dt= 1.0f/(float)(OrderT); // Parse all quads vertices corner. uint sl,tl; for(tl=0; tl<lenT+1; tl++) { float fs, ft; // compute t patch coordinates. ft= startT0 + (float)tl * dt ; for(sl=0; sl<lenS+1; sl++) { // compute s patch coordinates. fs= startS0 + (float)sl * ds ; // Must use computeContinousVertex, to ensure continous coordinate on patch edges quadBlock.Vertices[sl + tl*NL_PATCH_BLOCK_MAX_VERTEX]= computeContinousVertex(fs, ft); } } }

void NL3D::CPatch::fillTileVertexListVB (  CTessList< CTessNearVertex > &  vertList  )  [private]

Definition at line 1185 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), fillTileVertexVB(), and NL3D::CTessNodeList::Next. Referenced by fillVB(), and preRender(). { // Traverse the vertList. CTessNearVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next) { fillTileVertexVB(pVert); } }

void NL3D::CPatch::fillTileVertexVB (  CTessNearVertex *  pVert  )  [inline, private]

Definition at line 1109 of file patch_render.cpp. References NL3D::CTessVertex::EndPos, NL3D::CTessNearVertex::Index, NL3D::CTessVertex::MaxFaceSize, NL3D::CTessVertex::MaxNearLimit, nlassert, NL3D::CTessVertex::Pos, NL3D::CTessNearVertex::PUv0, NL3D::CTessNearVertex::PUv1, NL3D::CTessNearVertex::PUv2, NL3D::CTessNearVertex::Src, NL3D::CTessVertex::StartPos, NLMISC::CUV::U, uint8, and NLMISC::CUV::V. Referenced by checkFillVertexVBNear(), and fillTileVertexListVB(). { // The Buffers must have been locked nlassert(CLandscapeGlobals::CurrentTileVBAllocator); nlassert(CLandscapeGlobals::CurrentTileVBAllocator->bufferLocked()); // VBInfo must be OK. nlassert(!CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs()); static uint8 *CurVBPtr; // Compute/build the new vertex. CurVBPtr= (uint8*)CLandscapeGlobals::CurrentTileVBInfo.VertexCoordPointer; CurVBPtr+= pVert->Index * CLandscapeGlobals::CurrentTileVBInfo.VertexSize; // NB: the filling order of data is important, for AGP write combiners. // If not VertexProgram (NB: Suppose BTB kill this test). if( !CLandscapeGlobals::VertexProgramEnabled ) { // Set Pos. Set it local to the current center of landscape *(CVector*)CurVBPtr= pVert->Src->Pos - CLandscapeGlobals::PZBModelPosition; // Set Uvs. *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff0)= pVert->PUv0; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff1)= pVert->PUv1; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff2)= pVert->PUv2; } else { // Else must setup Vertex program inputs // v[0]== StartPos. *(CVector*)CurVBPtr= pVert->Src->StartPos; // v[8]== Tex0 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff0)= pVert->PUv0; // v[9]== Tex1 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff1)= pVert->PUv1; // v[13]== Tex2 *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.TexCoordOff2)= pVert->PUv2; // v[10]== GeomInfo. static CUV geomInfo; geomInfo.U= pVert->Src->MaxFaceSize * CLandscapeGlobals::OORefineThreshold; geomInfo.V= pVert->Src->MaxNearLimit; *(CUV*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.GeomInfoOff)= geomInfo; // v[11]== EndPos - StartPos *(CVector*)(CurVBPtr + CLandscapeGlobals::CurrentTileVBInfo.DeltaPosOff)= pVert->Src->EndPos - pVert->Src->StartPos; } }

void NL3D::CPatch::fillVB (   )

Definition at line 1198 of file patch_render.cpp. References NL3D::CTessBlock::FarVertexList, fillFar0VertexListVB(), fillFar1VertexListVB(), fillTileVertexListVB(), MasterBlock, NL3D::CTessBlock::NearVertexList, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, NL3D::CTessBlock::visibleFar0(), NL3D::CTessBlock::visibleFar1(), and NL3D::CTessBlock::visibleTile(). Referenced by fillVBIfVisible(), preRender(), and updateClipPatchVB(). { // Fill Far0. //======= // fill only if no reallcoation occurs if(Far0>0 && !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() ) { // Fill Far0 VB. fillFar0VertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // fill only if tblock visible. if( tblock.visibleFar0() ) fillFar0VertexListVB(tblock.FarVertexList); } } else if(Far0==0 && !CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs() ) { // Fill Tile VB. // No Tiles in MasterBlock!! // Traverse the TessBlocks to add vertices. for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // fill only if tblock visible. if( tblock.visibleTile() ) fillTileVertexListVB(tblock.NearVertexList); } } // Fill Far1. //======= if(Far1>0 && !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() ) { // Fill VB. fillFar1VertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // fill only if tblock visible. if( tblock.visibleFar1() ) fillFar1VertexListVB(tblock.FarVertexList); } } }

void NL3D::CPatch::fillVBFar0Only (   )

Definition at line 1256 of file patch_render.cpp. References NL3D::CTessBlock::FarVertexList, fillFar0VertexListVB(), MasterBlock, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and NL3D::CTessBlock::visibleFar0(). Referenced by preRender(). { if(Far0>0 && !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() ) { // Fill Far0 VB. fillFar0VertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // fill only if tblock visible. if( tblock.visibleFar0() ) fillFar0VertexListVB(tblock.FarVertexList); } } }

void NL3D::CPatch::fillVBFar1Only (   )

Definition at line 1274 of file patch_render.cpp. References NL3D::CTessBlock::FarVertexList, fillFar1VertexListVB(), MasterBlock, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and NL3D::CTessBlock::visibleFar1(). Referenced by preRender(). { if(Far1>0 && !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() ) { // Fill VB. fillFar1VertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // fill only if tblock visible. if( tblock.visibleFar1() ) fillFar1VertexListVB(tblock.FarVertexList); } } }

void NL3D::CPatch::fillVBFarsDLMUvOnly (   )

Definition at line 1720 of file patch_render.cpp. References NL3D::CTessBlock::FarVertexList, fillFar0DLMUvOnlyVertexListVB(), fillFar1DLMUvOnlyVertexListVB(), MasterBlock, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, NL3D::CTessBlock::visibleFar0(), and NL3D::CTessBlock::visibleFar1(). Referenced by addRefDLMContext(), and decRefDLMContext(). { // Do it for Far0. if(Far0>0 && !CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs() ) { // Fill Far0 VB. fillFar0DLMUvOnlyVertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // fill only if tblock visible. if( tblock.visibleFar0() ) fillFar0DLMUvOnlyVertexListVB(tblock.FarVertexList); } } // Do it for Far1. if(Far1>0 && !CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs() ) { // Fill VB. fillFar1DLMUvOnlyVertexListVB(MasterBlock.FarVertexList); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // fill only if tblock visible. if( tblock.visibleFar1() ) fillFar1DLMUvOnlyVertexListVB(tblock.FarVertexList); } } }

void NL3D::CPatch::fillVBIfVisible (   )

Definition at line 1248 of file patch_render.cpp. References fillVB(), and isRenderClipped(). Referenced by NL3D::CLandscape::render(). { if(isRenderClipped()==false) fillVB(); }

void NL3D::CPatch::forceMergeAtTileLevel (   )

For changing TileMaxSubdivision. force tesselation to be under tile. Definition at line 2022 of file patch.cpp. References NL3D::CTessFace::forceMergeAtTileLevel(), nlassert, Son0, and Son1. Referenced by NL3D::CZone::forceMergeAtTileLevel(). { nlassert(Son0 && Son1); Son0->forceMergeAtTileLevel(); Son1->forceMergeAtTileLevel(); }

void NL3D::CPatch::generateTileVegetable (  CVegetableInstanceGroup *  vegetIg, uint  distType, uint  ts, uint  tt, CLandscapeVegetableBlockCreateContext &  vbCreateCtx )  [private]

Create / init the vegetableBlock in the corresponding TessBlock. TessBlocks must exist. Definition at line 50 of file patch_vegetable.cpp. References _DLMContext, NL3D::CLandscape::_VegetableManager, NLMISC::CRGBAF::A, appendTileLightInfluences(), NLMISC::CRGBAF::B, NLMISC::clamp(), NL3D::CVegetableLightEx::computeCurrentColors(), NL3D::CPointLight::computeLinearAttenuation(), NL3D::CVegetableLightEx::Direction, NL3D::CPatchDLMContext::DLMUBias, NL3D::CPatchDLMContext::DLMUScale, NL3D::CPatchDLMContext::DLMVBias, NL3D::CPatchDLMContext::DLMVScale, NL3D::CLandscapeVegetableBlockCreateContext::eval(), NL3D::CBezierPatch::eval(), NL3D::CBezierPatch::evalNormal(), NLMISC::CRGBAF::G, NL3D::CVegetable::generateGroupBiLinear(), NL3D::CVegetable::generateInstance(), getLandscape(), NL3D::CPointLight::getPosition(), getTileLumelmapPrecomputed(), NL3D::CLandscape::getTileVegetableDesc(), NL3D::CTileVegetableDesc::getVegetableList(), NL3D::CTileVegetableDesc::getVegetableSeed(), NL3D::CPatchDLMContext::MaxU8, NL3D::CPatchDLMContext::MaxV8, min, NL3D::CPatchDLMContext::MinU8, NL3D::CPatchDLMContext::MinV8, NL3D_PATCH_TILE_AREA, NL3D_VEGETABLE_BLOCK_ELTDIST, NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE_SHIFT, nlassert, NLMISC::CVector::normalize(), NLMISC::CMatrix::normalize(), NL3D::CVegetableLightEx::NumLights, NLMISC::OptFastFloor(), NL3D::CVegetableLightEx::PointLight, NL3D::CVegetableLightEx::PointLightFactor, NLMISC::CRGBAF::R, NL3D::CVegetable::reserveIgAddInstances(), NL3D::CVegetableManager::reserveIgCompile(), NLMISC::CMatrix::setPos(), NLMISC::CMatrix::setRot(), sint, size, Tiles, NL3D::CVegetableUV8::U, NLMISC::CUV::U, uint, uint8, unpackIntoCache(), NL3D::CVegetableUV8::V, NLMISC::CUV::V, NL3D::CVegetableInstanceGroup::VegetableLightEx, x, NLMISC::CVector::x, y, and NLMISC::CVector::y. Referenced by NL3D::CLandscapeVegetableBlock::createVegetableIGForDistType(). { uint i; // Get tile infos for vegetable // ========================= // Get the state for this vegetable tile CTileElement::TVegetableInfo vegetWaterState= Tiles[tt * OrderS + ts].getVegetableState(); // If vegetable disabled, skip! if(vegetWaterState == CTileElement::VegetableDisabled) return; // get the tileId under this tile (<=> the tile material) uint tileId= Tiles[tt * OrderS + ts].Tile[0]; // get list of vegetable for this tile, and for hist distanceType category. const CTileVegetableDesc &tileVegetDesc= getLandscape()->getTileVegetableDesc(tileId); const std::vector<CVegetable> &vegetableList= tileVegetDesc.getVegetableList(distType); uint distAddSeed= tileVegetDesc.getVegetableSeed(distType); uint numVegetable= vegetableList.size(); // If no vegetables at all, skip. if(numVegetable==0) return; // compute approximate tile position and normal: get the middle float tileU= (ts + 0.5f) / (float)OrderS; float tileV= (tt + 0.5f) / (float)OrderT; CBezierPatch *bpatch= unpackIntoCache(); // Get approximate position for the tile (usefull for noise). NB: eval() is faster than computeVertex(). CVector tilePos= bpatch->eval(tileU, tileV); // Get also the normal used for all instances on this tile (not precise, // don't take noise into account, but faster). CVector tileNormal= bpatch->evalNormal(tileU, tileV); // Compute also position on middle of 4 edges of this tile, for generateGroupBiLinear(). CVector tilePosBiLinear[4]; float OOos= 1.0f / OrderS; float OOot= 1.0f / OrderT; tilePosBiLinear[0]= bpatch->eval( (ts + 0.0f) * OOos, (tt + 0.5f) * OOot); tilePosBiLinear[1]= bpatch->eval( (ts + 1.0f) * OOos, (tt + 0.5f) * OOot); tilePosBiLinear[2]= bpatch->eval( (ts + 0.5f) * OOos, (tt + 0.0f) * OOot); tilePosBiLinear[3]= bpatch->eval( (ts + 0.5f) * OOos, (tt + 1.0f) * OOot); // compute a rotation matrix with the normal CMatrix matInstance; matInstance.setRot(CVector::I, CVector::J, tileNormal); // must normalize the matrix. use the vector which is the most orthogonal to tileNormal // If tileNormal is much more a J vector, then use plane (I,tileNormal), and vice-versa if(fabs(tileNormal.y) > fabs(tileNormal.x)) matInstance.normalize(CMatrix::ZXY); else matInstance.normalize(CMatrix::ZYX); // prepare color / lighting // ========================= // say that ambient never change. VegetableManager handle the ambient and diffuse itself (for precomputeLighting) CRGBAF ambientF= CRGBAF(1,1,1,1); // Compute the tileLightmap (not modified by tileColor). static uint8 tileLumelmap[NL_LUMEL_BY_TILE * NL_LUMEL_BY_TILE]; getTileLumelmapPrecomputed(ts, tt, tileLumelmap, NL_LUMEL_BY_TILE); // compute diffuse color by substracting from ambient. CRGBAF diffuseColorF[NL_LUMEL_BY_TILE * NL_LUMEL_BY_TILE]; // TODO_VEGET_OPTIM: optimize this. // For all lumel of this tile. for(i= 0; i<NL_LUMEL_BY_TILE*NL_LUMEL_BY_TILE; i++) { // mul by 2, because shade is done twice here: by vertex, and by landscape. sint tileLumel= 2*tileLumelmap[i]; tileLumel= min(tileLumel, 255); float tlf= tileLumel / 255.f; diffuseColorF[i].R= tlf; diffuseColorF[i].G= tlf; diffuseColorF[i].B= tlf; diffuseColorF[i].A= 1; } // Compute The CVegetableLightEx, adding pointLight effect to vegetation // First get pointLight at this tiles. static vector<CPointLightInfluence> lightList; lightList.clear(); appendTileLightInfluences( CUV(tileU, tileV), lightList); // for each light, modulate the factor of influence for(i=0; i<lightList.size();i++) { CPointLight *pl= lightList[i].PointLight; // compute the attenuation to the pos of the tile float att= pl->computeLinearAttenuation(tilePos); // modulate the influence with this factor lightList[i].BkupInfluence= lightList[i].Influence; lightList[i].Influence*= att; } // sort the light by influence sort(lightList.begin(), lightList.end()); // Setup the vegetLex directly in the ig. CVegetableLightEx &vegetLex= vegetIg->VegetableLightEx; // take only 2 first, computing direction to tilePos and computing attenuation. vegetLex.NumLights= min((uint)CVegetableLightEx::MaxNumLight, (uint)lightList.size()); for(i=0;i<vegetLex.NumLights;i++) { // WARNING: can C cast to CPointLightNamed here because comes from CPatch::appendTileLightInfluences() only! CPointLightNamed *pl= (CPointLightNamed*)(lightList[i].PointLight); // copy to vegetLex. vegetLex.PointLight[i]= pl; // get the attenuation vegetLex.PointLightFactor[i]= (uint)(256* lightList[i].Influence); // Setup the direction from pointLight. vegetLex.Direction[i]= tilePos - pl->getPosition(); vegetLex.Direction[i].normalize(); } // compute now the current colors of the vegetLex. vegetLex.computeCurrentColors(); // Compute Dynamic Lightmap UV for this tile. nlassert(_DLMContext); CUV dlmUV; // get coordinate in 0..1 in texture. dlmUV.U= _DLMContext->DLMUBias + _DLMContext->DLMUScale * tileU; dlmUV.V= _DLMContext->DLMVBias + _DLMContext->DLMVScale * tileV; // get coordinate in 0..255. CVegetableUV8 dlmUV8; dlmUV8.U= (uint8)NLMISC::OptFastFloor(dlmUV.U * 255 + 0.5f); dlmUV8.V= (uint8)NLMISC::OptFastFloor(dlmUV.V * 255 + 0.5f); // bound them, ensuring 8Bits UV "uncompressed" by driver are in the lightmap area. clamp(dlmUV8.U, _DLMContext->MinU8, _DLMContext->MaxU8); clamp(dlmUV8.V, _DLMContext->MinV8, _DLMContext->MaxV8); // for all vegetable of this list, generate instances. // ========================= // Get an array for each vegetable (static for speed). typedef std::vector<NLMISC::CVector2f> TPositionVector; static std::vector<TPositionVector> instanceUVArray; // realloc if necessary. if(instanceUVArray.size() < numVegetable) { // clean. contReset(instanceUVArray); // realloc. instanceUVArray.resize(numVegetable); } // First, for each vegetable, generate the number of instance to create, and their relative position. for(i= 0; i<numVegetable; i++) { // get the vegetable const CVegetable &veget= vegetableList[i]; // generate instance for this vegetable. veget.generateGroupBiLinear(tilePos, tilePosBiLinear, tileNormal, NL3D_PATCH_TILE_AREA, i + distAddSeed, instanceUVArray[i]); } // Then, now that we kno how many instance to generate for each vegetable, reserve space. CVegetableInstanceGroupReserve vegetIgReserve; for(i= 0; i<numVegetable; i++) { // get the vegetable const CVegetable &veget= vegetableList[i]; // reseve instance space for this vegetable. // instanceUVArray[i].size() is the number of instances to create. veget.reserveIgAddInstances(vegetIgReserve, (CVegetable::TVegetableWater)vegetWaterState, instanceUVArray[i].size()); } // actual reseve memory of the ig. getLandscape()->_VegetableManager->reserveIgCompile(vegetIg, vegetIgReserve); // generate the instances for all the vegetables. for(i= 0; i<numVegetable; i++) { // get the vegetable const CVegetable &veget= vegetableList[i]; // get the relatives position of the instances std::vector<CVector2f> &instanceUV= instanceUVArray[i]; // For all instance, generate the real instances. for(uint j=0; j<instanceUV.size(); j++) { // generate the position in world Space. // instanceUV is in [0..1] interval, which maps to a tile, so explode to the patch CVector instancePos; vbCreateCtx.eval(ts, tt, instanceUV[j].x, instanceUV[j].y, instancePos); // NB: use same normal for rotation for all instances in a same tile. matInstance.setPos( instancePos ); // peek color into the lightmap. sint lumelS= NLMISC::OptFastFloor(instanceUV[j].x * NL_LUMEL_BY_TILE); sint lumelT= NLMISC::OptFastFloor(instanceUV[j].y * NL_LUMEL_BY_TILE); clamp(lumelS, 0, NL_LUMEL_BY_TILE-1); clamp(lumelT, 0, NL_LUMEL_BY_TILE-1); // generate the instance of the vegetable veget.generateInstance(vegetIg, matInstance, ambientF, diffuseColorF[ (lumelT<<NL_LUMEL_BY_TILE_SHIFT) + lumelS ], (distType+1) * NL3D_VEGETABLE_BLOCK_ELTDIST, (CVegetable::TVegetableWater)vegetWaterState, dlmUV8); } } }

void NL3D::CPatch::getBindNeighbor (  uint  edge, CBindInfo &  neighborEdge )  const

return neighborhood information. Definition at line 2213 of file patch.cpp. References _BindZoneNeighbor, NL3D::CZone::buildBindInfo(), getZone(), NL3D::CPatch::CBindInfo::MultipleBindNum, nlassert, NL3D::CPatch::CBindInfo::NPatchs, uint, and NL3D::CPatch::CBindInfo::Zone. Referenced by bind(), NL3D::CZone::bindPatch(), NL3D::CZoneCornerSmoother::buildPatchBindInfo(), NL3D::CZoneLighter::buildZoneInformation(), computeContinousVertex(), computeDisplaceCornerSmooth(), computeDisplaceEdgeSmooth(), computeDisplaceRawOnNeighbor(), computeNearBlockLightmap(), computeNormalCornerSmooth(), computeNormalEdgeSmooth(), computeNormalOnNeighbor(), and computeTileLightmapPixelAroundCorner(). { nlassert(edge<4); if(_BindZoneNeighbor[edge]!=NULL) { getZone()->buildBindInfo(PatchId, edge, _BindZoneNeighbor[edge], neighborEdge); } else { neighborEdge.Zone= NULL; neighborEdge.NPatchs= 0; neighborEdge.MultipleBindNum= 0; } }

bool NL3D::CPatch::getCornerSmoothFlag (  uint  corner  )  const

Definition at line 962 of file patch_noise.cpp. References _CornerSmoothFlag, nlassert, and uint. Referenced by computeNearBlockLightmap(), computeNormalCornerSmooth(), and NL3D::CZone::retrieve(). { nlassert(corner<=3); uint mask= 1<<corner; return (_CornerSmoothFlag& mask)!=0; }

const CTessVertex* NL3D::CPatch::getCornerVertex (  uint  corner  )  [inline]

Definition at line 659 of file patch.h. References BaseVertices, and uint. Referenced by NL3D::CZoneCornerSmoother::computeAllCornerSmoothFlags(). { return BaseVertices[corner]; }

void NL3D::CPatch::getCurrentTileTLIColors (  uint  ts, uint  tt, NLMISC::CRGBA  corners[4] )  [private]

Definition at line 1655 of file patch_lightmap.cpp. References NL3D::CZone::_PointLightArray, NLMISC::CRGBA::avg2RGBOnly(), NL3D::CPointLightNamedArray::getPointLights(), getZone(), uint, x, and y. Referenced by addTileLightmapEdgeWithTLI(), addTileLightmapPixelWithTLI(), and addTileLightmapWithTLI(). { // Get ref on array of PointLightNamed. if( getZone()->_PointLightArray.getPointLights().size() >0 ) { // get coord of the tessBlock uint tbs= ts>>1; uint tbt= tt>>1; // get tile id local to tessBlock. uint tls= ts-(tbs<<1); uint tlt= tt-(tbt<<1); // For each corner of the tessBlock, compute lighting with pointLights. CRGBA tbCorners[4]; for(uint y=0;y<2;y++) { for(uint x=0;x<2;x++) { CRGBA &cornerCol= tbCorners[y*2+x]; cornerCol= getCurrentTLIColor(tbs+x, tbt+y); } } // Then biLinear to tile Level (tessBlock==2x2 tiles). CRGBA tbEdges[4]; CRGBA tbMiddle; // left. tbEdges[0].avg2RGBOnly(tbCorners[0], tbCorners[2]); // bottom tbEdges[1].avg2RGBOnly(tbCorners[2], tbCorners[3]); // right tbEdges[2].avg2RGBOnly(tbCorners[1], tbCorners[3]); // up tbEdges[3].avg2RGBOnly(tbCorners[0], tbCorners[1]); // middle. tbMiddle.avg2RGBOnly(tbEdges[0], tbEdges[2]); // just copy result according to tile pos in tessBlock. if(tlt==0) { if(tls==0) { corners[0]= tbCorners[0]; corners[1]= tbEdges[3]; corners[2]= tbEdges[0]; corners[3]= tbMiddle; } else { corners[0]= tbEdges[3]; corners[1]= tbCorners[1]; corners[2]= tbMiddle; corners[3]= tbEdges[2]; } } else { if(tls==0) { corners[0]= tbEdges[0]; corners[1]= tbMiddle; corners[2]= tbCorners[2]; corners[3]= tbEdges[1]; } else { corners[0]= tbMiddle; corners[1]= tbEdges[2]; corners[2]= tbEdges[1]; corners[3]= tbCorners[3]; } } } else { // Just fill with 0s. corners[0]= CRGBA::Black; corners[1]= CRGBA::Black; corners[2]= CRGBA::Black; corners[3]= CRGBA::Black; } }

float NL3D::CPatch::getErrorSize (   )  const [inline]

Definition at line 395 of file patch.h. References ErrorSize. {return ErrorSize;}

sint NL3D::CPatch::getFar0 (   )  const [inline]

Definition at line 396 of file patch.h. References sint. Referenced by NL3D::CLandscape::render(). {return Far0;}

sint NL3D::CPatch::getFar1 (   )  const [inline]

Definition at line 397 of file patch.h. References sint. Referenced by NL3D::CLandscape::render(). {return Far1;}

CLandscape * NL3D::CPatch::getLandscape (   )  const

Get the landscape in which is placed this patch. Definition at line 2186 of file patch.cpp. References NL3D::CZone::getLandscape(). Referenced by addRefDLMContext(), addRefTessBlocks(), NL3D::CTessFace::allocTileUv(), appendFaceToTileRenderList(), appendTileMaterialToRenderList(), NL3D::CTessFace::buildTileFaces(), clearTessBlocks(), NL3D::CPatchDLMContext::computeTextureFar(), computeTileLightmap(), computeTileLightmapEdge(), computeTileLightmapEdgePrecomputed(), computeTileLightmapPixel(), computeTileLightmapPixelAutomatic(), computeTileLightmapPixelPrecomputed(), computeTileLightmapPrecomputed(), computeVertex(), createFaceVectorFar0OrTile(), createFaceVectorFar1(), createVegetableBlock(), deleteFaceVectorFar0OrTile(), deleteFaceVectorFar1(), NL3D::CTessFace::deleteTileFaces(), NL3D::CTessFace::deleteTileUv(), dirtTessBlockFaceVector(), NL3D::CTessFace::doMerge(), generateTileVegetable(), makeRoots(), recreateAllVegetableIgs(), recreateTessBlockFaceVector(), release(), NL3D::CTessFace::releaseTileMaterial(), releaseVegetableBlock(), removeFaceFromTileRenderList(), removeTileMaterialFromRenderList(), NL3D::CTessFace::split(), NL3D::CTessFace::splitRectangular(), NL3D::CTessFace::unbind(), NL3D::CTessFace::updateBindAndSplit(), NL3D::CTessFace::updateRefineMerge(), and NL3D::CTessFace::updateRefineSplit(). { return Zone->getLandscape(); }

uint8 NL3D::CPatch::getLumel (  const CUV &  uv  )  const

Get the lumel under the position. Definition at line 1499 of file patch_lightmap.cpp. References NLMISC::clamp(), getTileLumelmapPixelPrecomputed(), NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE_SHIFT, NLMISC::OptFastFloor(), sint, NLMISC::CUV::U, uint8, NLMISC::CUV::V, and w. Referenced by NL3D::CLandscape::getLumel(). { // compute tile coord and lumel coord. sint ts, tt; // get in lumel coord. sint w= (OrderS<<NL_LUMEL_BY_TILE_SHIFT); sint h= (OrderT<<NL_LUMEL_BY_TILE_SHIFT); // fastFloor: use a precision of 256 to avoid doing OptFastFloorBegin. // add 128, to round and get cneter of lumel. ts= NLMISC::OptFastFloor(uv.U* (w<<8) + 128); ts>>=8; tt= NLMISC::OptFastFloor(uv.V* (h<<8) + 128); tt>>=8; clamp(ts, 0, w-1); clamp(tt, 0, h-1); // get the lumel uint8 ret; getTileLumelmapPixelPrecomputed(ts>>NL_LUMEL_BY_TILE_SHIFT, tt>>NL_LUMEL_BY_TILE_SHIFT, ts&(NL_LUMEL_BY_TILE-1), tt&(NL_LUMEL_BY_TILE-1), ret); return ret; }

CPatch* NL3D::CPatch::getNextFar0ToRdr (   )  const [inline]

Definition at line 465 of file patch.h. References _NextRdrFar0. Referenced by NL3D::CLandscape::render(). {return _NextRdrFar0;}

CPatch* NL3D::CPatch::getNextFar1ToRdr (   )  const [inline]

Definition at line 467 of file patch.h. References _NextRdrFar1. Referenced by NL3D::CLandscape::render(). {return _NextRdrFar1;}

CPatch* NL3D::CPatch::getNextNearUL (   )  const [inline]

For lighting update, get Next (CiruclarList). If ==this, then list is empty. Definition at line 750 of file patch.h. References _ULNearNext. Referenced by NL3D::CLandscape::unlinkPatchFromNearUL(), and NL3D::CLandscape::updateLightingTextureNear(). {return _ULNearNext;}

uint NL3D::CPatch::getNumNearTessBlocks (   )  const [inline]

get the number of Near TessBlocks. Actually OrderS/2*OrderT/2. Definition at line 753 of file patch.h. References NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by NL3D::CLandscape::updateLightingTextureNear(). {return TessBlocks.size();}

void NL3D::CPatch::getNumTessBlock (  CParamCoord  pc, TFarVertType &  type, uint &  numtb )  [private]

Definition at line 738 of file patch.cpp. References FVMasterBlock, FVTessBlock, FVTessBlockEdge, NL3D::CParamCoord::S, NL3D::CParamCoord::T, type, and uint. { uint tboS= (uint)(OrderS>>1); uint tboT= (uint)(OrderT>>1); // Coordinate of the tessblock (2*2 a tile!! so the >>1). uint ts= ((uint)pc.S * tboS) / 0x8000; uint tt= ((uint)pc.T * tboT) / 0x8000; numtb= tt*tboS + ts; bool edgeS= (ts*0x8000) == ((uint)pc.S * tboS); bool edgeT= (tt*0x8000) == ((uint)pc.T * tboT); // Does this vertex lies on a corner of a TessBlock? if(edgeS && edgeT) type= FVMasterBlock; // Does this vertex lies on a edge of a TessBlock? else if(edgeS || edgeT) type= FVTessBlockEdge; // Else it lies exclusively IN a TessBlock. else type= FVTessBlock; }

uint NL3D::CPatch::getNumTessBlock (  CTessFace *  face  )  [private]

Definition at line 722 of file patch.cpp. References NL3D::CTessFace::PVBase, NL3D::CTessFace::PVLeft, NL3D::CTessFace::PVRight, NL3D::CParamCoord::S, NL3D::CParamCoord::T, and uint. Referenced by appendFaceToRenderList(), appendFaceToTileRenderList(), appendFarVertexToRenderList(), extendTessBlockWithEndPos(), removeFaceFromRenderList(), removeFaceFromTileRenderList(), and removeFarVertexFromRenderList(). { // To which tessBlocks link the face? // compute an approx middle of the face. CParamCoord edgeMid(face->PVLeft, face->PVRight); CParamCoord middle(edgeMid, face->PVBase); // Coordinate of the tessblock (2*2 a tile!! so the >>1). uint ts= ((uint)middle.S * (uint)(OrderS>>1)) / 0x8000; uint tt= ((uint)middle.T * (uint)(OrderT>>1)) / 0x8000; uint numtb= tt*(uint)(OrderS>>1) + ts; return numtb; }

uint8 NL3D::CPatch::getOrderForEdge (  sint8  edge  )  const

Definition at line 2196 of file patch.cpp. References sint, sint8, uint, and uint8. Referenced by NL3D::CPatchUVLocator::build(). { uint e= ((sint)edge + 256)&3; // If an horizontal edge. if( e&1 ) return OrderS; else return OrderT; }

uint8 NL3D::CPatch::getOrderS (   )  const [inline]

Definition at line 392 of file patch.h. References uint8. Referenced by NL3D::CTextureFar::allocatePatch(), NL3D::CPatchUVLocator::build(), NL3D::CLandscape::buildCollideFaces(), NL3D::CZoneLighter::buildZoneInformation(), computeContinousVertex(), computeNormalCornerSmooth(), computeNormalEdgeSmooth(), computeNormalOnNeighbor(), NL3D::CPatchDLMContext::computeTextureFar(), NL3D::CLandscapeVegetableBlockCreateContext::eval(), NL3D::CLandscape::freeFarRenderPass(), NL3D::CPatchDLMContext::generate(), NL3D::CLandscape::getFarRenderPass(), NL3D::CZoneLighter::getNormal(), NL3D::CLandscapeVegetableBlock::init(), NL3D::CZoneLighter::isLumelOnEdgeMustBeOversample(), NL3D::CTextureFar::rebuildPatch(), NL3D::CTextureFar::removePatch(), NL3D::CPatchUVLocator::selectPatch(), NL3D::CTextureFar::touchPatchULAndNext(), and NL3D::CTextureFar::tryAllocatePatch(). {return OrderS;}

uint8 NL3D::CPatch::getOrderT (   )  const [inline]

Definition at line 393 of file patch.h. References uint8. Referenced by NL3D::CTextureFar::allocatePatch(), NL3D::CPatchUVLocator::build(), NL3D::CLandscape::buildCollideFaces(), NL3D::CZoneLighter::buildZoneInformation(), computeContinousVertex(), computeNormalCornerSmooth(), computeNormalEdgeSmooth(), computeNormalOnNeighbor(), NL3D::CPatchDLMContext::computeTextureFar(), NL3D::CLandscapeVegetableBlockCreateContext::eval(), NL3D::CLandscape::freeFarRenderPass(), NL3D::CPatchDLMContext::generate(), NL3D::CLandscape::getFarRenderPass(), NL3D::CZoneLighter::getNormal(), NL3D::CLandscapeVegetableBlock::init(), NL3D::CTextureFar::rebuildPatch(), NL3D::CTextureFar::removePatch(), NL3D::CPatchUVLocator::selectPatch(), NL3D::CTextureFar::touchPatchULAndNext(), and NL3D::CTextureFar::tryAllocatePatch(). {return OrderT;}

uint16 NL3D::CPatch::getPatchId (   )  const [inline]

Definition at line 398 of file patch.h. References uint16. Referenced by NL3D::CZoneLighter::buildZoneInformation(), NL3D::CLandscape::computeDynamicLighting(), NL3D::CZoneLighter::getNormal(), and NL3D::CZoneLighter::isLumelOnEdgeMustBeOversample(). {return PatchId;}

CTessFace * NL3D::CPatch::getRootFaceForEdge (  sint  edge  )  const [private]

Definition at line 1751 of file patch.cpp. References nlassert, sint, Son0, and Son1. Referenced by bind(). { nlassert(edge>=0 && edge<=3); // See tessellation rules. if(OrderS>=OrderT) { if(edge==0 || edge==1) return Son0; else return Son1; } else { if(edge==0 || edge==3) return Son0; else return Son1; } }

CTessVertex * NL3D::CPatch::getRootVertexForEdge (  sint  edge  )  const [private]

Definition at line 1773 of file patch.cpp. References nlassert, sint, Son0, Son1, NL3D::CTessFace::VBase, NL3D::CTessFace::VLeft, and NL3D::CTessFace::VRight. Referenced by bind(). { // Return the vertex which is the start of edge. nlassert(edge>=0 && edge<=3); // See tessellation rules. if(OrderS>=OrderT) { switch(edge) { case 0: return Son0->VRight; case 1: return Son0->VBase; case 2: return Son0->VLeft; case 3: return Son1->VBase; default: return NULL; } } else { switch(edge) { case 0: return Son0->VBase; case 1: return Son0->VLeft; case 2: return Son1->VBase; case 3: return Son0->VRight; default: return NULL; } } }

bool NL3D::CPatch::getSmoothFlag (  uint  edge  )  const [inline]

Get the smooth flag for the n-th edge. Return true if this edge must by smoothed, false else. Definition at line 579 of file patch.h. References NL_PATCH_SMOOTH_FLAG_SHIFT, and uint. Referenced by NL3D::CZoneCornerSmoother::buildPatchBindInfo(), computeNearBlockLightmap(), computeNormalEdgeSmooth(), and NL3D::CZoneLighter::getNormal(). { // Test it return ((Flags&(1<<(edge+NL_PATCH_SMOOTH_FLAG_SHIFT)))!=0); }

CVector NL3D::CPatch::getTesselatedPos (  CUV  uv  )  const

From the current tesselation of this patch, and a UV in this patch, return tesselated position. Definition at line 579 of file patch.cpp. References NLMISC::clamp(), NL3D::CTessFace::getTesselatedPos(), Son0, Son1, NLMISC::CUV::U, and NLMISC::CUV::V. Referenced by NL3D::CLandscape::getTesselatedPos(). { // clamp values. clamp(uv.U, 0, 1); clamp(uv.V, 0, 1); // recurs down the 2 sons. CVector ret= CVector::Null; Son0->getTesselatedPos(uv, true, ret); Son1->getTesselatedPos(uv, true, ret); return ret; }

CTileElement * NL3D::CPatch::getTileElement (  const CUV &  uv  )

Get the lumel under the position. Definition at line 2265 of file patch.cpp. References NLMISC::clamp(), NLMISC::OptFastFloor(), sint, Tiles, NLMISC::CUV::U, and NLMISC::CUV::V. Referenced by NL3D::CLandscape::getTileElement(). { // compute tile coord and lumel coord. sint ts, tt; // fastFloor: use a precision of 256 to avoid doing OptFastFloorBegin. // add 128, to round and get cneter of lumel. ts= NLMISC::OptFastFloor(uv.U* (OrderS<<8) + 128); ts>>=8; tt= NLMISC::OptFastFloor(uv.V* (OrderT<<8) + 128); tt>>=8; clamp(ts, 0, OrderS-1); clamp(tt, 0, OrderT-1); // get the lumel return &(Tiles[ts+tt*OrderS]); }

void NL3D::CPatch::getTileLightMap (  uint  ts, uint  tt, CPatchRdrPass *&  rdrpass )  [private]

Definition at line 1191 of file patch_lightmap.cpp. References computeNearBlockLightmap(), computeTbTm(), NL3D::CLandscape::getTileLightMap(), NL3D::CZone::Landscape, NL3D::CTessBlock::LightMapId, NL3D::CTessBlock::LightMapRdrPass, NL3D::CTessBlock::LightMapRefCount, NL_TILE_LIGHTMAP_SIZE, nlassert, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. { // TessBlocks must have been allocated. nlassert(TessBlocks.size()!=0); // get what tessBlock to use. uint numtb, numtm; computeTbTm(numtb, numtm, ts, tt); CTessBlock &tessBlock= TessBlocks[numtb]; // If the lightmap Id has not been computed, compute it. if(tessBlock.LightMapRefCount==0) { // Compute the lightmap texture, with help of TileColors, with neighboring info etc... CRGBA lightText[NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE]; computeNearBlockLightmap(ts&(~1), tt&(~1), lightText); // Create a rdrPass with this texture, donlod to Driver etc... tessBlock.LightMapId= Zone->Landscape->getTileLightMap(lightText, rdrpass); // store this rdrpass ptr. tessBlock.LightMapRdrPass= rdrpass; } // We are using this 2x2 tiles lightmap. tessBlock.LightMapRefCount++; // get the rdrpass ptr of the tessBlock lightmap rdrpass= tessBlock.LightMapRdrPass; }

void NL3D::CPatch::getTileLightMapUvInfo (  uint  ts, uint  tt, CVector &  uvScaleBias )  [private]

Definition at line 1225 of file patch_lightmap.cpp. References computeTbTm(), NL3D::CLandscape::getTileLightMapUvInfo(), NL3D::CZone::Landscape, NL3D::CTessBlock::LightMapId, nlassert, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, uint, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by NL3D::CTessFace::initTileUvLightmap(). { // TessBlocks must have been allocated. nlassert(TessBlocks.size()!=0); // get what tessBlock to use. uint numtb, numtm; computeTbTm(numtb, numtm, ts, tt); CTessBlock &tessBlock= TessBlocks[numtb]; // Get the uvScaleBias for the tile 0,0 of the block. Zone->Landscape->getTileLightMapUvInfo(tessBlock.LightMapId, uvScaleBias); // Must increment the bias, for the good tile in the 2x2 block Lightmap. uint tsDec= ts & 1; uint ttDec= tt & 1; uvScaleBias.x+= tsDec * uvScaleBias.z; uvScaleBias.y+= ttDec * uvScaleBias.z; }

void NL3D::CPatch::getTileLumelmapPixelPrecomputed (  uint  ts, uint  tt, uint  s, uint  t, uint8 &  dest )  const [private]

same as computeTileLightmapPixelPrecomputed, but brut result, not modified by colorTable. Actually used for Lightmap get interface. Definition at line 670 of file patch_lightmap.cpp. References CompressedLumels, NL3D::getUnpackLumelBlock(), NL_BLOCK_LUMEL_COMPRESSED_SIZE, s, t, uint, and uint8. Referenced by getLumel(). { // Return the lumel dest= getUnpackLumelBlock (&(CompressedLumels[(ts + (tt*OrderS))*NL_BLOCK_LUMEL_COMPRESSED_SIZE]), s+(t<<2)); }

void NL3D::CPatch::getTileLumelmapPrecomputed (  uint  ts, uint  tt, uint8 *  dest, uint  stride )  [private]

Create / init the vegetableBlock in the corresponding TessBlock. TessBlocks must exist. Definition at line 650 of file patch_lightmap.cpp. References buffer, CompressedLumels, NL_BLOCK_LUMEL_COMPRESSED_SIZE, NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE_SHIFT, stride, uint, uint8, unpackLumelBlock(), x, and y. Referenced by generateTileVegetable(). { // Unpack the lumels uint8 buffer[NL_LUMEL_BY_TILE*NL_LUMEL_BY_TILE]; unpackLumelBlock (buffer, &(CompressedLumels[(ts + (tt*OrderS))*NL_BLOCK_LUMEL_COMPRESSED_SIZE])); // Retrun it uint x, y; for(y=0; y<NL_LUMEL_BY_TILE; y++) { for(x=0; x<NL_LUMEL_BY_TILE; x++) { // lumel dest[y*stride + x]= buffer[x+(y<<NL_LUMEL_BY_TILE_SHIFT)]; } } }

uint NL3D::CPatch::getTileMaterialRefCount (   )  const [inline]

Get number of TileMaterial created in this Patch. Definition at line 788 of file patch.h. References MasterBlock, NL3D::CTessBlock::TileMaterialRefCount, and uint. Referenced by NL3D::CLandscape::render(). {return MasterBlock.TileMaterialRefCount;}

CPatchRdrPass * NL3D::CPatch::getTileRenderPass (  sint  tileId, sint  pass )  [private]

Definition at line 2040 of file patch.cpp. References NL3D::CLandscape::getTileRenderPass(), NL3D::CZone::Landscape, NL3D_TILE_PASS_ADD, NL3D_TILE_PASS_RGB0, NL3D_TILE_PASS_RGB1, NL3D_TILE_PASS_RGB2, nlassert, sint, and Tiles. { // All but lightmap. nlassert(pass==NL3D_TILE_PASS_RGB0 || pass==NL3D_TILE_PASS_RGB1 || pass==NL3D_TILE_PASS_RGB2 || pass==NL3D_TILE_PASS_ADD); bool additive= (pass==NL3D_TILE_PASS_ADD); sint passNum= pass-NL3D_TILE_PASS_RGB0; // If additive, take the additve tile of bigger existing pass. if(additive) { // Default: take addtive of pass 0. passNum= 0; // If the pass1 is not empty, may take its tile. if(Tiles[tileId].Tile[1]!=0xFFFF) { passNum= 1; // If the pass2 is not empty, take its tile. if(Tiles[tileId].Tile[2]!=0xFFFF) passNum= 2; } } sint tileNumber= Tiles[tileId].Tile[passNum]; if(tileNumber==0xFFFF) { // Display a "fake" only if pass 0. if(pass==NL3D_TILE_PASS_RGB0) return Zone->Landscape->getTileRenderPass(0xFFFF, false); // Else, this tile do not have such a pass (not a transition). return NULL; } else { // return still may be NULL, in additive case. return Zone->Landscape->getTileRenderPass(tileNumber, additive); } }

void NL3D::CPatch::getTileTileColors (  uint  ts, uint  tt, NLMISC::CRGBA  corners[4] )  [private]

Definition at line 345 of file patch_lightmap.cpp. References NL3D::CTileColor::Color565, NLMISC::CRGBA::set565(), sint, TileColors, and uint. Referenced by modulateTileLightmapEdgeWithTileColors(), modulateTileLightmapPixelWithTileColors(), and modulateTileLightmapWithTileColors(). { for(sint i=0;i<4;i++) { CTileColor &tcol= TileColors[ (tt+(i>>1))*(OrderS+1) + (ts+(i&1)) ]; CRGBA &col= corners[i]; col.set565 (tcol.Color565); } }

void NL3D::CPatch::getTileUvInfo (  sint  tileId, sint  pass, bool  alpha, uint8 &  orient, CVector &  uvScaleBias, bool &  is256x256, uint8 &  uvOff )  [private]

Definition at line 2080 of file patch.cpp. References alpha, NL3D::CLandscape::getTileUvScaleBiasRot(), NL3D::CZone::Landscape, NL3D_TILE_PASS_ADD, NL3D_TILE_PASS_RGB0, NL3D_TILE_PASS_RGB1, NL3D_TILE_PASS_RGB2, nlassert, sint, Tiles, type, uint8, NLMISC::CVector::x, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by NL3D::CTessFace::initTileUvRGBA(). { // All but lightmap. nlassert(pass==NL3D_TILE_PASS_RGB0 || pass==NL3D_TILE_PASS_RGB1 || pass==NL3D_TILE_PASS_RGB2 || pass==NL3D_TILE_PASS_ADD); bool additive= (pass==NL3D_TILE_PASS_ADD); sint passNum= pass-NL3D_TILE_PASS_RGB0; // If additive, take the additve tile of bigger existing pass. if(additive) { // Default: take addtive of pass 0. passNum= 0; // If the pass1 is not empty, may take its tile. if(Tiles[tileId].Tile[1]!=0xFFFF) { passNum= 1; // If the pass2 is not empty, take its tile. if(Tiles[tileId].Tile[2]!=0xFFFF) passNum= 2; } } sint tileNumber= Tiles[tileId].Tile[passNum]; if(tileNumber==0xFFFF) { // dummy... Should not be called here. orient= 0; uvScaleBias.x=0; uvScaleBias.y=0; uvScaleBias.z=1; is256x256=false; uvOff=0; } else { orient= Tiles[tileId].getTileOrient(passNum); Tiles[tileId].getTile256Info(is256x256, uvOff); CTile::TBitmap type; // If alpha wanted, return its UV info (works either for Alpha in Diffuse Pass and Alpha in Additive Pass) if(alpha) type= CTile::alpha; else { if(additive) type= CTile::additive; else type= CTile::diffuse; } uint8 rotalpha; Zone->Landscape->getTileUvScaleBiasRot(tileNumber, type, uvScaleBias, rotalpha); // Add the special rotation of alpha. if(alpha) orient= (orient+rotalpha)&3; } }

CZone* NL3D::CPatch::getZone (   )  const [inline]

Definition at line 391 of file patch.h. Referenced by appendTileLightInfluences(), NL3D::CZoneLighter::buildZoneInformation(), computeDisplaceRawInteger(), NL3D::CLandscape::computeDynamicLighting(), getBindNeighbor(), getCurrentTileTLIColors(), NL3D::CZoneLighter::getNormal(), and NL3D::CTextureFar::rebuildPatch(). {return Zone;}

bool NL3D::CPatch::isRenderClipped (   )  const

Definition at line 594 of file patch.cpp. References NL3D::CZone::isPatchRenderClipped(). Referenced by addRefDLMContext(), beginDLMLighting(), checkCreateVertexVBFar(), checkCreateVertexVBNear(), checkDeleteVertexVBFar(), checkDeleteVertexVBNear(), checkFillVertexVBFar(), checkFillVertexVBNear(), computeSoftwareGeomorphAndAlpha(), decRefDLMContext(), dirtTessBlockFaceVector(), fillVBIfVisible(), makeRoots(), processDLMLight(), recreateTessBlockFaceVector(), release(), NL3D::CLandscape::render(), renderFar0(), renderFar1(), and resetMasterBlock(). { if(Zone) return Zone->isPatchRenderClipped(PatchId); else return true; }

void NL3D::CPatch::linkBeforeNearUL (  CPatch *  patchNext  )

For lighting update, insert this before patchNext (CiruclarList). textNext must be !NULL. Definition at line 1880 of file patch_lightmap.cpp. References _ULNearNext, _ULNearPrec, and nlassert. Referenced by NL3D::CLandscape::linkPatchToNearUL(). { nlassert(patchNext); // first, unlink others from me. NB: works even if _ULNearPrec==_ULNearNext==this. _ULNearNext->_ULNearPrec= _ULNearPrec; _ULNearPrec->_ULNearNext= _ULNearNext; // link to igNext. _ULNearNext= patchNext; _ULNearPrec= patchNext->_ULNearPrec; // link others to me. _ULNearNext->_ULNearPrec= this; _ULNearPrec->_ULNearNext= this; }

CTessFace * NL3D::CPatch::linkTessFaceWithEdge (  const NLMISC::CVector2f &  uv0, const NLMISC::CVector2f &  uv1, CTessFace *  linkTo )  [private]

Used by bind(). Search in the tesselation the first face which own the edge uv0-uv1. link it with linkTo, and return it. NULL if not found (obviously because not so tesselated) Definition at line 1834 of file patch.cpp. References NL3D::CTessFace::linkTessFaceWithEdge(), nlassert, Son0, and Son1. Referenced by bind(). { nlassert(Son0 && Son1); // Try to link with Root Son0 CTessFace *face= Son0->linkTessFaceWithEdge(uv0, uv1, linkTo); // if Failed Try to link with Root Son1 if(!face) face= Son1->linkTessFaceWithEdge(uv0, uv1, linkTo); return face; }

void NL3D::CPatch::makeRoots (   )  [private]

Definition at line 1124 of file patch.cpp. References appendFaceToRenderList(), appendFarVertexToRenderList(), BaseFarVertices, BaseVertices, clearTessBlocks(), NL3D::CTessFace::computeSplitPoint(), computeVertex(), NL3D::CTessVertex::EndPos, ErrorSize, NL3D::CTessFace::FBase, NL3D::CTessFace::FLeft, NL3D::CTessFace::FRight, NL3D::CTessFace::FVBase, NL3D::CTessFace::FVLeft, NL3D::CTessFace::FVRight, getLandscape(), isRenderClipped(), NL3D::CTessFace::Level, NL3D::CTessVertex::MaxFaceSize, NL3D::CTessVertex::MaxNearLimit, NL3D::CLandscape::newTessFace(), nlassert, NL3D::CTessFace::Patch, NL3D::CTessFarVertex::PCoord, NL3D::CTessVertex::Pos, NL3D::CTessFace::PVBase, NL3D::CTessFace::PVLeft, NL3D::CTessFace::PVRight, resetMasterBlock(), NL3D::CParamCoord::setST(), NL3D::CTessFace::Size, Son0, Son1, NL3D::CTessFarVertex::Src, NL3D::CTessVertex::StartPos, NL3D::CTessFace::VBase, NL3D::CTessFace::VLeft, and NL3D::CTessFace::VRight. Referenced by compile(). { CTessVertex *a= BaseVertices[0]; CTessVertex *b= BaseVertices[1]; CTessVertex *c= BaseVertices[2]; CTessVertex *d= BaseVertices[3]; // Set positions. a->Pos= a->StartPos= a->EndPos= computeVertex(0,0); b->Pos= b->StartPos= b->EndPos= computeVertex(0,1); c->Pos= c->StartPos= c->EndPos= computeVertex(1,1); d->Pos= d->StartPos= d->EndPos= computeVertex(1,0); // Init Far vetices. CTessFarVertex *fa= &BaseFarVertices[0]; CTessFarVertex *fb= &BaseFarVertices[1]; CTessFarVertex *fc= &BaseFarVertices[2]; CTessFarVertex *fd= &BaseFarVertices[3]; fa->Src= a; fa->PCoord.setST(0,0); fb->Src= b; fb->PCoord.setST(0,1); fc->Src= c; fc->PCoord.setST(1,1); fd->Src= d; fd->PCoord.setST(1,0); // We don't have to fill the Far vertices VB here, because this patch is still not visible. // NB: we can't because we don't have any driver here. nlassert(isRenderClipped()==true); // Make Roots. /* Tesselation layout. For Square Face, and if OrderS>=OrderT. A-------D |\ Son1 | | \ | | \ | | Son0 \| B-------C For rectangles whith OrderT>OrderS. It is VERY IMPORTANT, for splitRectangular() reasons. A-------D | Son0 /| | / | | / | |/ Son1 | B-------C */ nlassert(Son0==NULL); nlassert(Son1==NULL); Son0= getLandscape()->newTessFace(); Son1= getLandscape()->newTessFace(); // Son0. Son0->Patch= this; Son0->Level= 0; if(OrderS>=OrderT) { Son0->VBase= b; Son0->VLeft= c; Son0->VRight= a; Son0->FVBase= fb; Son0->FVLeft= fc; Son0->FVRight= fa; Son0->PVBase.setST(0, 1); Son0->PVLeft.setST(1, 1); Son0->PVRight.setST(0, 0); } else { Son0->VBase= a; Son0->VLeft= b; Son0->VRight= d; Son0->FVBase= fa; Son0->FVLeft= fb; Son0->FVRight= fd; Son0->PVBase.setST(0, 0); Son0->PVLeft.setST(0, 1); Son0->PVRight.setST(1, 0); } Son0->FBase= Son1; Son0->FLeft= NULL; Son0->FRight= NULL; // No tile info. Son0->Size= ErrorSize/2; Son0->computeSplitPoint(); // Son1. Son1->Patch= this; Son1->Level= 0; if(OrderS>=OrderT) { Son1->VBase= d; Son1->VLeft= a; Son1->VRight= c; Son1->FVBase= fd; Son1->FVLeft= fa; Son1->FVRight= fc; Son1->PVBase.setST(1, 0); Son1->PVLeft.setST(0, 0); Son1->PVRight.setST(1, 1); } else { Son1->VBase= c; Son1->VLeft= d; Son1->VRight= b; Son1->FVBase= fc; Son1->FVLeft= fd; Son1->FVRight= fb; Son1->PVBase.setST(1, 1); Son1->PVLeft.setST(1, 0); Son1->PVRight.setST(0, 1); } Son1->FBase= Son0; Son1->FLeft= NULL; Son1->FRight= NULL; // No tile info. Son1->Size= ErrorSize/2; Son1->computeSplitPoint(); // Prepare the render list... clearTessBlocks(); resetMasterBlock(); appendFarVertexToRenderList(fa); appendFarVertexToRenderList(fb); appendFarVertexToRenderList(fc); appendFarVertexToRenderList(fd); appendFaceToRenderList(Son0); appendFaceToRenderList(Son1); // Usefull for geomorph: Init 2 root faces MaxNearLimit, and MaxFaceSize // NB: since no geomorph is made on endpoints (StartPos==EndPos) of patchs, this is not usefull. // but it is important to ensure the VP or software geomorph won't crash with bad float values. // Init MaxFaceSize. Son0->VBase->MaxFaceSize= 1; Son0->VLeft->MaxFaceSize= 1; Son0->VRight->MaxFaceSize= 1; Son1->VBase->MaxFaceSize= 1; Son1->VLeft->MaxFaceSize= 1; Son1->VRight->MaxFaceSize= 1; // Init MaxNearLimit. Son0->VBase->MaxNearLimit= 1; Son0->VLeft->MaxNearLimit= 1; Son0->VRight->MaxNearLimit= 1; Son1->VBase->MaxNearLimit= 1; Son1->VLeft->MaxNearLimit= 1; Son1->VRight->MaxNearLimit= 1; }

void NL3D::CPatch::modulateTileLightmapEdgeWithTileColors (  uint  ts, uint  tt, uint  edge, NLMISC::CRGBA *  dest, uint  stride, bool  inverse )  [private]

Definition at line 508 of file patch_lightmap.cpp. References NL3D::bilinearColorAndModulatex2(), getTileTileColors(), NL_LUMEL_BY_TILE, stride, uint, x, and y. Referenced by computeTileLightmapEdge(). { // Get the tileColors around this tile CRGBA corners[4]; getTileTileColors(ts, tt, corners); // get coordinate according to edge. uint x=0,y=0; switch(edge) { case 0: x= 0; break; case 1: y= NL_LUMEL_BY_TILE-1; break; case 2: x= NL_LUMEL_BY_TILE-1; break; case 3: y= 0; break; }; // For all lumel of the edge, bilinear. uint i; for(i=0; i<NL_LUMEL_BY_TILE; i++) { // if vertical edge if( (edge&1)==0 ) y= i; // else horizontal edge else x= i; // manage inverse. uint where; if(inverse) where= (NL_LUMEL_BY_TILE-1)-i; else where= i; // compute this pixel, and modulate bilinearColorAndModulatex2(corners, x, y, dest[where*stride]); } }

void NL3D::CPatch::modulateTileLightmapPixelWithTileColors (  uint  ts, uint  tt, uint  s, uint  t, NLMISC::CRGBA *  dest )  [private]

Definition at line 544 of file patch_lightmap.cpp. References NL3D::bilinearColorAndModulatex2(), getTileTileColors(), s, t, and uint. Referenced by computeTileLightmapPixel(). { // Get the tileColors around this tile CRGBA corners[4]; getTileTileColors(ts, tt, corners); // compute this pixel, and modulate bilinearColorAndModulatex2(corners, s, t, *dest); }

void NL3D::CPatch::modulateTileLightmapWithTileColors (  uint  ts, uint  tt, NLMISC::CRGBA *  dest, uint  stride )  [private]

Definition at line 488 of file patch_lightmap.cpp. References NL3D::bilinearColorAndModulatex2(), getTileTileColors(), NL_LUMEL_BY_TILE, stride, uint, x, and y. Referenced by computeTileLightmap(). { // Get the tileColors around this tile CRGBA corners[4]; getTileTileColors(ts, tt, corners); // For all lumel, bilinear. uint x, y; for(y=0; y<NL_LUMEL_BY_TILE; y++) { for(x=0; x<NL_LUMEL_BY_TILE; x++) { // compute this pixel, and modulate bilinearColorAndModulatex2(corners, x, y, dest[y*stride + x]); } } }

void NL3D::CPatch::packLumelBlock (  uint8 *  dest, const uint8 *  source, uint8  alpha0, uint8  alpha1 )  [private]

Pack a 4x4 lumel block See also: packShadowMap(), unpackShadowMap() Definition at line 261 of file patch_lightmap.cpp. References NL3D::NL3DDecompressLumelFactor0Case0, NL3D::NL3DDecompressLumelFactor0Case1, NL3D::NL3DDecompressLumelFactor1Case0, NL3D::NL3DDecompressLumelFactor1Case1, sint, uint, uint8, and value. Referenced by packShadowMap(). { // Precalc the height values.. uint8 value[8]; // For each value uint i; for (i=0; i<8; i++) { // Case 0 or 1 ? if (alpha0>alpha1) // Case 0 value[i]=(NL3DDecompressLumelFactor0Case0[i]*alpha0+NL3DDecompressLumelFactor1Case0[i]*alpha1)/7; else { if (i<6) value[i]=(NL3DDecompressLumelFactor0Case1[i]*alpha0+NL3DDecompressLumelFactor1Case1[i]*alpha1)/5; else if (i==6) value[i]=0; else value[i]=255; } } // Store alpha value dest[0]=alpha0; dest[1]=alpha1; // Clear dest codes for (i=0; i<6; i++) { // Clear the code dest[2+i]=0; } // For each original select the best uint codeOffset=2; sint codeShift=5; for (i=0; i<16; i++) { // Best dist and code uint bestDist=10000; uint8 bestCode=0; // Calc distance for (uint code=0; code<8; code++) { // Distance from original value uint dist=abs ((sint)(source[i])-(sint)(value[code])); // The best ? if (dist<bestDist) { // New best bestDist=dist; bestCode=code; } // Perfect, stop searching if (dist==0) break; } // Store the best if (codeShift>=0) dest[codeOffset]|=bestCode<<codeShift; else { dest[codeOffset]|=bestCode>>(-codeShift); dest[codeOffset+1]|=bestCode<<(8+codeShift); } // Next shift codeShift-=3; if (codeShift<=-3) { codeOffset++; codeShift+=8; } } }

void NL3D::CPatch::packShadowMap (  const uint8 *  pLumel  )

Pack the lumels of the patches. Lumels are classes that describe the lighting environnement at a given texel of the lightmap. It is used to compute the shadow map of the patch, compress it and uncompress it. This method compress the lumels passed in parameter and stored them in its Lumels member. Parameters: pShadow  is a pointer on the destination lumel buffer. Size must be (OrderS*4+1)*(OrderS*4+1). See also: unpackShadowMap(), resetCompressedLumels() Definition at line 1267 of file patch_lightmap.cpp. References CompressedLumels, evalLumelBlock(), NL_BLOCK_LUMEL_COMPRESSED_SIZE, NL_LUMEL_BY_TILE, nlassert, packLumelBlock(), uint, uint8, unpackLumelBlock(), and v. Referenced by NL3D::CZone::build(). { // Number of lumel by lines uint lumelCount=OrderS*NL_LUMEL_BY_TILE; // Number of block in a line nlassert ((lumelCount&0x3)==0); uint numLumelBlock=lumelCount>>2; // Number of line uint lineCount=OrderT*NL_LUMEL_BY_TILE; // Number of block line nlassert ((lineCount&0x3)==0); uint numLineBlock=lineCount>>2; // Resize the compressed buffer CompressedLumels.resize (numLumelBlock*numLineBlock*NL_BLOCK_LUMEL_COMPRESSED_SIZE); // Input of compresed data uint8 *compressedData=&CompressedLumels[0]; // Each line block for (uint lineBlock=0; lineBlock<numLineBlock; lineBlock++) { // Block pointer const uint8 *blockLine=pLumelSrc; // Each lumel block for (uint lumelBlock=0; lumelBlock<numLumelBlock; lumelBlock++) { // *** Unpack the block uint countU; // Last block ? if (lumelBlock==numLumelBlock-1) countU=lumelCount&3; else countU=4; // Destination lumel const uint8 *blockSrc=blockLine; // Temp block uint8 originalBlock[4*4]; // Copy the lumels in the bloc for (uint v=0; v<NL_LUMEL_BY_TILE; v++) { for (uint u=0; u<NL_LUMEL_BY_TILE; u++) { // Copy the lumel originalBlock[(v<<2)+u]=blockSrc[u]; } // Next line blockSrc+=lumelCount; } // Get min and max alpha uint8 alphaMin=255; uint8 alphaMax=0; // Scan for (uint i=0; i<16; i++) { // Min ? if (originalBlock[i]<alphaMin) alphaMin=originalBlock[i]; if (originalBlock[i]>alphaMax) alphaMax=originalBlock[i]; } // *** Try to compress by 2 methods // Blcok uncompressed uint8 uncompressedBlock[4*4]; // Pack the block packLumelBlock (compressedData, originalBlock, alphaMin, alphaMax); // Unpack the block unpackLumelBlock (uncompressedBlock, compressedData); // Eval error uint firstMethod=evalLumelBlock (originalBlock, uncompressedBlock, NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE); // second compression uint8 secondCompressedBlock[NL_BLOCK_LUMEL_COMPRESSED_SIZE]; packLumelBlock (secondCompressedBlock, originalBlock, alphaMax, alphaMin); // Unpack the block unpackLumelBlock (uncompressedBlock, secondCompressedBlock); // Eval error uint secondMethod=evalLumelBlock (originalBlock, uncompressedBlock, NL_LUMEL_BY_TILE, NL_LUMEL_BY_TILE); // Second best ? if (secondMethod<firstMethod) { // Copy compressed data memcpy (compressedData, secondCompressedBlock, NL_BLOCK_LUMEL_COMPRESSED_SIZE); } // Next source block compressedData+=NL_BLOCK_LUMEL_COMPRESSED_SIZE; // Next block on the line blockLine+=4; } // Next line of block pLumelSrc+=lumelCount*4; } }

void NL3D::CPatch::preRender (  const NLMISC::CBSphere &  patchSphere  )

preRender this patch. Build Max faces / pass etc... Definition at line 249 of file patch_render.cpp. References _PatchRdrPassFar0, _PatchRdrPassFar1, allocateVBAndFaceVector(), allocateVBAndFaceVectorFar1Only(), NL3D::CPatchRdrPass::appendRdrPatchFar0(), NL3D::CPatchRdrPass::appendRdrPatchFar1(), NL3D::CTileMaterial::appendTileToEachRenderPass(), NL3D::CTessBlock::clip(), NL3D::CTessBlock::clipFar(), computeNewFar(), deleteVBAndFaceVector(), deleteVBAndFaceVectorFar1Only(), NL3D::CTessBlock::FaceTileMaterialRefCount, NL3D::CTessBlock::FarVertexList, fillFar0VertexListVB(), fillFar1VertexListVB(), fillTileVertexListVB(), fillVB(), fillVBFar0Only(), fillVBFar1Only(), NL3D::CTessBlock::forceClip(), NL3D::CTessBlock::NearVertexList, NL3D_TESSBLOCK_TILESIZE, NumRenderableFaces, NL3D::CTessBlock::RdrTileRoot, NL3D::CTessBlock::refillFaceVectorFar0(), NL3D::CTessBlock::refillFaceVectorFar1(), NL3D::CTessBlock::refillFaceVectorTile(), NL3D::CTessBlock::resetClip(), sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, uint, updateFar0VBAlloc(), updateFar1VBAlloc(), updateTileVBAlloc(), NL3D::CTessBlock::visibleFar0(), NL3D::CTessBlock::visibleFar1(), and NL3D::CTessBlock::visibleTile(). { // 0. Classify the patch, and update TextureInfo. //======================= sint newFar0,newFar1; // compute new Far0 and new Far1. computeNewFar(patchSphere, newFar0, newFar1); // 2. Update vertices in VB //======================== sint oldFar0= Far0, oldFar1= Far1; // Test if go in or go out tileMode. bool changeTileMode; // this is true if a change is made, and if old or current is in TileMode. changeTileMode= (newFar0!=oldFar0) && (newFar0==0 || oldFar0==0); // Or this is true if Far0 / Far1 was invalid before. changeTileMode= changeTileMode || oldFar0==-1 || oldFar1==-1; // Pre VB change. //------------------ // In this case, major change: delete all VB, then recreate after. if(changeTileMode) { // delete the old VB (NB: isRenderClipped()==false here). // NB: Far0 and Far1 are still unmodified, so deleteVB() will do the good job. deleteVBAndFaceVector(); } else { // minor change: Far0 UV, or Far1. // Far0 UV: do nothing here. // If change in Far1, must delete Far1 if(newFar1!=oldFar1) { // NB: Far1 is still unmodified, so deleteVB() will do the good job. deleteVBAndFaceVectorFar1Only(); } } // Far change. //------------------ // Set new far values Far0= newFar0; Far1= newFar1; // Post VB change. //------------------ if(changeTileMode) { // major change: recreate all the VB. allocateVBAndFaceVector(); // Then try to refill if possible. fillVB(); } else { // minor change: Far0 UV, or Far1. // If change in Far0 if(newFar0!=oldFar0) { // Then must recompute VB with good UVs. // An optimisation is to check if UVs had really change (see UScale ...) // but the case they don't change is very rare: 1/16. fillVBFar0Only(); } // If change in Far1, must allcoate and recompute UVs. if(newFar1!=oldFar1) { allocateVBAndFaceVectorFar1Only(); // try to fill if no reallocation problem fillVBFar1Only(); } } // 3. Append patch to renderList. //===================== // This patch is visible. So if good far, append. if(Far0>0) { _PatchRdrPassFar0->appendRdrPatchFar0(this); } // Same for Far1. if(Far1>0) { _PatchRdrPassFar1->appendRdrPatchFar1(this); } // 4. Clip tess blocks. //===================== // If we are in Tile/FarTransition bool doClipFar= Far0==0 && Far1==1; // Parse all TessBlocks. uint nTessBlock= TessBlocks.size(); CTessBlock *pTessBlock= nTessBlock>0? &TessBlocks[0]: NULL ; for(; nTessBlock>0; pTessBlock++, nTessBlock--) { CTessBlock &tblock= *pTessBlock; // bkup the old result for clipping bool oldVisibleFar0= tblock.visibleFar0(); bool oldVisibleTile= tblock.visibleTile(); bool oldVisibleFar1= tblock.visibleFar1(); // If this TessBlock is empty, do not need to clip if(tblock.FaceTileMaterialRefCount==0) { // Simply force the clip. tblock.forceClip(); } else { // clip the tessBlock. tblock.resetClip(); tblock.clip(); // If we are in Tile/FarTransition if(doClipFar) tblock.clipFar(CLandscapeGlobals::RefineCenter, CLandscapeGlobals::TileDistNear, CLandscapeGlobals::FarTransition); // If TileMode, and if tile visible if(Far0==0 && tblock.visibleTile() ) { // Append all tiles (if any) to the renderPass list! for(uint j=0;j<NL3D_TESSBLOCK_TILESIZE; j++) { // If tile exist if(tblock.RdrTileRoot[j]) // add it to the renderList tblock.RdrTileRoot[j]->appendTileToEachRenderPass(NumRenderableFaces); } } } // If change of clip in tessBlock, must update the tessBlock if( Far0> 0 && oldVisibleFar0 != tblock.visibleFar0() ) { if( tblock.visibleFar0() ) { // allocate updateFar0VBAlloc(tblock.FarVertexList, true); // fill only if possible. if(!CLandscapeGlobals::CurrentFar0VBAllocator->reallocationOccurs()) fillFar0VertexListVB(tblock.FarVertexList); // rebuild triangles index list. tblock.refillFaceVectorFar0(); } else { // delete updateFar0VBAlloc(tblock.FarVertexList, false); } } if( Far0==0 && oldVisibleTile != tblock.visibleTile() ) { if( tblock.visibleTile() ) { // allocate updateTileVBAlloc(tblock.NearVertexList, true); // fill only if possible. if(!CLandscapeGlobals::CurrentTileVBAllocator->reallocationOccurs()) fillTileVertexListVB(tblock.NearVertexList); // rebuild triangles index list. tblock.refillFaceVectorTile(); } else { // delete updateTileVBAlloc(tblock.NearVertexList, false); } } if( Far1> 0 && oldVisibleFar1 != tblock.visibleFar1() ) { if( tblock.visibleFar1() ) { // allocate updateFar1VBAlloc(tblock.FarVertexList, true); // fill only if possible. if(!CLandscapeGlobals::CurrentFar1VBAllocator->reallocationOccurs()) fillFar1VertexListVB(tblock.FarVertexList); // rebuild triangles index list. tblock.refillFaceVectorFar1(); } else { // delete updateFar1VBAlloc(tblock.FarVertexList, false); } } } }

void NL3D::CPatch::processDLMLight (  CPatchDLMPointLight &  pl  )

Process a Dynamic light, creating the DLMContext if necessary. Increment RefCount. Called by CLandscape. Definition at line 2021 of file patch_lightmap.cpp. References _DLMContext, NL3D::CPatchDLMContext::addPointLightInfluence(), addRefDLMContext(), NL3D::CPatchDLMContext::CurPointLightCount, and isRenderClipped(). { // add reference to currentLight, creating DLMContext if needed addRefDLMContext(); // add curLight counter _DLMContext->CurPointLightCount++; // compute lighting, only if patch is visible if(!isRenderClipped()) _DLMContext->addPointLightInfluence(pl); }

void NL3D::CPatch::recreateAllVegetableIgs (   )

Recreate any vegetable block (as possible) in this patch. (usefull for edition). Definition at line 260 of file patch_vegetable.cpp. References createVegetableBlock(), getLandscape(), NL3D::CLandscape::isVegetableActive(), NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by NL3D::CLandscape::enableVegetable(). { // For all TessBlocks, try to release their VegetableBlock for(uint numtb=0; numtb<TessBlocks.size(); numtb++) { // if the vegetableBlock is deleted, and if there is at least one Material in the tessBlock, and if possible if( TessBlocks[numtb].VegetableBlock==NULL && TessBlocks[numtb].TileMaterialRefCount>0 && getLandscape()->isVegetableActive()) { // compute tessBlock coordinate uint tbWidth= OrderS>>1; uint ts= numtb&(tbWidth-1); uint tt= numtb/tbWidth; // crate the vegetable with tilecooridante (ie tessBlock coord *2); createVegetableBlock(numtb, ts*2, tt*2); } } }

void NL3D::CPatch::recreateTessBlockFaceVector (  CTessBlock &  block  )

Definition at line 705 of file patch_render.cpp. References NL3D::CTessBlock::createFaceVectorFar0(), NL3D::CTessBlock::createFaceVectorFar1(), NL3D::CTessBlock::createFaceVectorTile(), getLandscape(), isRenderClipped(), and MasterBlock. Referenced by NL3D::CLandscape::updateTessBlocksFaceVector(). { // Do it Only if patch is visible. if(!isRenderClipped()) { // Far0. // If Far Mode. if(Far0>0) { // Create the face for this TessBlock only. block.createFaceVectorFar0(getLandscape()->_FaceVectorManager); } // Or If Tile Mode. else if(Far0==0) { // No tiles in MasterBlock! So no need to call createFaceVectorTile(), if this block is the MasterBlock. if(&block != &MasterBlock) block.createFaceVectorTile(getLandscape()->_FaceVectorManager); } // Far1. if(Far1>0) { // Create the face for this TessBlock only. block.createFaceVectorFar1(getLandscape()->_FaceVectorManager); } } }

void NL3D::CPatch::recreateTileUvs (   )

Definition at line 2150 of file patch.cpp. References NL3D::CTessList< CTileFace >::clear(), NLMISC::CObjectVector< CTessBlock >::clear(), NL3D_MAX_TILE_FACE, NL3D_TESSBLOCK_TILESIZE, NL3D::CTessFace::recreateTileUvs(), sint, NLMISC::CObjectVector< CTessBlock >::size(), Son0, Son1, TessBlocks, and NL3D::CTileMaterial::TileFaceList. { // Reset the Tile rdr list. for(sint tb=0; tb<(sint)TessBlocks.size();tb++) { // Vertices must all be reseted. TessBlocks[tb].NearVertexList.clear(); for(sint i=0;i<NL3D_TESSBLOCK_TILESIZE;i++) { CTileMaterial *tm= TessBlocks[tb].RdrTileRoot[i]; if(tm) { for(sint pass=0;pass<NL3D_MAX_TILE_FACE;pass++) { tm->TileFaceList[pass].clear(); } } } } Son0->recreateTileUvs(); Son1->recreateTileUvs(); }

void NL3D::CPatch::refineAll (   )

Refine this patch. Even if clipped. Refine all nodes. Definition at line 1493 of file patch.cpp. References nlassert, NL3D::CTessFace::refineAll(), Son0, and Son1. Referenced by NL3D::CZone::refineAll(). { // refineAll. nlassert(Son0); nlassert(Son1); Son0->refineAll(); Son1->refineAll(); }

void NL3D::CPatch::refreshTesselationGeometry (   )

Definition at line 1531 of file patch.cpp. References BaseVertices, computeVertex(), NL3D::CTessVertex::EndPos, nlassert, NL3D::CTessVertex::Pos, NL3D::CTessFace::refreshTesselationGeometry(), Son0, Son1, and NL3D::CTessVertex::StartPos. { nlassert(Son0); nlassert(Son1); // Recompute the BaseVertices. CTessVertex *a= BaseVertices[0]; CTessVertex *b= BaseVertices[1]; CTessVertex *c= BaseVertices[2]; CTessVertex *d= BaseVertices[3]; // Set positions. a->Pos= a->StartPos= a->EndPos= computeVertex(0,0); b->Pos= b->StartPos= b->EndPos= computeVertex(0,1); c->Pos= c->StartPos= c->EndPos= computeVertex(1,1); d->Pos= d->StartPos= d->EndPos= computeVertex(1,0); // refresh the tesselation of sons. Son0->refreshTesselationGeometry(); Son1->refreshTesselationGeometry(); }

void NL3D::CPatch::release (   )

Un-compile a patch. Tesselation is deleted. if patch is not compiled, no - op. Definition at line 115 of file patch.cpp. References _DLMContext, _DLMContextRefCount, NL3D::CZone::_PatchOldRenderClipped, NL3D::CZone::_PatchRenderClipped, _ULNearNext, _ULNearPrec, clearTessBlocks(), NL3D::CLandscape::deleteTessFace(), deleteVBAndFaceVector(), NL3D::CTessFace::FLeft, NL3D::CTessFace::FRight, getLandscape(), NL3D::CTessFace::isLeaf(), isRenderClipped(), nlassert, resetMasterBlock(), resetRenderFar(), NLMISC::CBitSet::set(), Son0, and Son1. Referenced by NL3D::CZone::release(), and ~CPatch(). { if(Zone) { // First, delete the VB if the zone was removed while the patch is visible. if(!isRenderClipped()) { // release VertexBuffer. deleteVBAndFaceVector(); // Flag RenderClipped in Zone Zone->_PatchRenderClipped.set(PatchId, true); } // THIS PATCH MSUT BE UNBOUND FIRST!!!!! nlassert(Son0 && Son1); nlassert(Son0->isLeaf() && Son1->isLeaf()); nlassert(Son0->FLeft == NULL); nlassert(Son0->FRight == NULL); nlassert(Son1->FLeft == NULL); nlassert(Son1->FRight == NULL); // Free renderPass of landscape, and maybe force computation of texture info on next preRender(). // Must do it here, before deletion of Zone, OrderS/T etc... resetRenderFar(); getLandscape()->deleteTessFace(Son0); getLandscape()->deleteTessFace(Son1); // Vertices are smartptr/deleted in zone. } // Flag the fact that this patch can't be rendered. OrderS=0; OrderT=0; Son0=NULL; Son1=NULL; clearTessBlocks(); resetMasterBlock(); // Flag RenderClipped in Zone if(Zone) { Zone->_PatchRenderClipped.set( PatchId, true); Zone->_PatchOldRenderClipped.set( PatchId, true); } // the pathc is uncompiled. must do it after clearTessBlocks(), because may use it // for vegetable manager, and for updateLighting Zone= NULL; // uncompile: reset UpdateLighting circular list to NULL. if(_ULNearPrec!= NULL) { // verify the patch is correctly unlinked from any ciruclar list. nlassert(_ULNearPrec==this && _ULNearNext==this); } _ULNearPrec= NULL; _ULNearNext= NULL; // DynamciLightMap: release the _DLMContext if still exist. if(_DLMContext) delete _DLMContext; // reset _DLMContext= NULL; _DLMContextRefCount= 0; }

void NL3D::CPatch::releaseTileLightMap (  uint  ts, uint  tt )  [private]

Definition at line 1247 of file patch_lightmap.cpp. References computeTbTm(), NL3D::CZone::Landscape, NL3D::CTessBlock::LightMapId, NL3D::CTessBlock::LightMapRefCount, nlassert, NL3D::CLandscape::releaseTileLightMap(), NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by NL3D::CTessFace::releaseTileMaterial(). { // TessBlocks must have been allocated. nlassert(TessBlocks.size()!=0); // get what tessBlock to use. uint numtb, numtm; computeTbTm(numtb, numtm, ts, tt); CTessBlock &tessBlock= TessBlocks[numtb]; // If no more tileMaterial use this lightmap, release it. nlassert(tessBlock.LightMapRefCount>0); tessBlock.LightMapRefCount--; if(tessBlock.LightMapRefCount==0) { Zone->Landscape->releaseTileLightMap(tessBlock.LightMapId); } }

void NL3D::CPatch::releaseVegetableBlock (  uint  numTb  )  [private]

release the vegetableBlock in the corresponding TessBlock. TessBlocks must exist Definition at line 326 of file patch_vegetable.cpp. References getLandscape(), TessBlocks, and uint. Referenced by deleteAllVegetableIgs(), and removeTileMaterialFromRenderList(). { // if exist, must delete the VegetableBlock. if(TessBlocks[numTb].VegetableBlock) { // delete Igs, and remove from list. TessBlocks[numTb].VegetableBlock->release(getLandscape()->_VegetableManager, getLandscape()->_VegetableBlockList); // delete. delete TessBlocks[numTb].VegetableBlock; TessBlocks[numTb].VegetableBlock= NULL; } }

void NL3D::CPatch::removeFaceFromRenderList (  CTessFace *  face  )  [private]

Definition at line 848 of file patch.cpp. References decRefTessBlocks(), dirtTessBlockFaceVector(), NL3D::CTessBlock::FaceTileMaterialRefCount, NL3D::CTessBlock::FarFaceList, getNumTessBlock(), NL3D::CTessFace::Level, MasterBlock, nlassert, NumRenderableFaces, NL3D::CTessList< CTessFace >::remove(), removeFaceFromTileRenderList(), TessBlockLimitLevel, TessBlocks, and uint. Referenced by NL3D::CTessFace::doMerge(), NL3D::CTessFace::split(), and NL3D::CTessFace::splitRectangular(). { // Update the number of renderable Faces NumRenderableFaces--; nlassert(NumRenderableFaces>=0); // Update Gnal render. //==================== if(face->Level<TessBlockLimitLevel) { MasterBlock.FarFaceList.remove(face); MasterBlock.FaceTileMaterialRefCount--; // The facelist is modified, so we must update the faceVector, if visible. dirtTessBlockFaceVector(MasterBlock); } else { // link the face to the good tessblock. uint numtb= getNumTessBlock(face); TessBlocks[numtb].FarFaceList.remove(face); TessBlocks[numtb].FaceTileMaterialRefCount--; // The facelist is modified, so we must update the faceVector, if visible. dirtTessBlockFaceVector(TessBlocks[numtb]); // Update Tile render (no need to do it if face not at least at tessblock level). removeFaceFromTileRenderList(face); // Destroy if necessary the TessBlocks. decRefTessBlocks(); } }

void NL3D::CPatch::removeFaceFromTileRenderList (  CTessFace *  face  )  [private]

Definition at line 913 of file patch.cpp. References dirtTessBlockFaceVector(), getLandscape(), getNumTessBlock(), NL3D_MAX_TILE_FACE, nlassert, NL3D::CTileMaterial::Pass, NL3D::CRdrTileId::PatchRdrPass, NL3D::CTessList< CTileFace >::remove(), NL3D::CLandscape::removeFromShadowPolyReceiver(), sint, TessBlocks, NL3D::CTileMaterial::TileFaceList, NL3D::CTessFace::TileFaces, NL3D::CTessFace::TileMaterial, and uint. Referenced by NL3D::CTessFace::deleteTileUvs(), and removeFaceFromRenderList(). { if(face->TileMaterial) { // For all valid faces, update their links. // Do not do this for lightmap, since it use same face from RGB0 pass. for(sint i=0;i<NL3D_MAX_TILE_FACE;i++) { CPatchRdrPass *tilePass= face->TileMaterial->Pass[i].PatchRdrPass; // If tile i enabled. if(tilePass) { // a face should have created for this pass. nlassert(face->TileFaces[i]); face->TileMaterial->TileFaceList[i].remove(face->TileFaces[i]); } } // The facelist is modified, so we must update the faceVector, if visible. uint numtb= getNumTessBlock(face); dirtTessBlockFaceVector(TessBlocks[numtb]); // Shadow: remove it from the Shadow Triangles. getLandscape()->removeFromShadowPolyReceiver(face); } }

void NL3D::CPatch::removeFarVertexFromRenderList (  CTessFarVertex *  fv  )  [private]

Definition at line 1062 of file patch.cpp. References decRefTessBlocks(), NL3D::CTessBlock::FarVertexList, FVMasterBlock, FVTessBlockEdge, getNumTessBlock(), MasterBlock, NL3D::CTessFarVertex::OwnerBlock, NL3D::CTessFarVertex::PCoord, NL3D::CTessList< CTessFarVertex >::remove(), TessBlocks, TFarVertType, type, and uint. Referenced by NL3D::CTessFace::doMerge(). { TFarVertType type; uint numtb; getNumTessBlock(fv->PCoord, type, numtb); if(type==FVMasterBlock || type==FVTessBlockEdge) { MasterBlock.FarVertexList.remove(fv); fv->OwnerBlock= NULL; } else { TessBlocks[numtb].FarVertexList.remove(fv); fv->OwnerBlock= NULL; // Destroy if necessary the TessBlocks. decRefTessBlocks(); } }

void NL3D::CPatch::removeNearVertexFromRenderList (  CTileMaterial *  tileMat, CTessNearVertex *  nv )  [private]

Definition at line 1099 of file patch.cpp. References computeTbTm(), decRefTessBlocks(), nlassert, NL3D::CTessNearVertex::OwnerBlock, TessBlocks, NL3D::CTileMaterial::TileS, NL3D::CTileMaterial::TileT, and uint. Referenced by NL3D::CTessFace::deleteTileUv(). { nlassert(tileMat); uint numtb, numtm; computeTbTm(numtb, numtm, tileMat->TileS, tileMat->TileT); TessBlocks[numtb].NearVertexList.remove(nv); nv->OwnerBlock= NULL; // Destroy if necessary the TessBlocks. decRefTessBlocks(); }

void NL3D::CPatch::removeTileMaterialFromRenderList (  CTileMaterial *  tm  )  [private]

Definition at line 1002 of file patch.cpp. References computeTbTm(), decRefDLMContext(), decRefTessBlocks(), getLandscape(), NL3D::CLandscape::getTileCallback(), MasterBlock, nlassert, releaseVegetableBlock(), TessBlocks, NL3D::CTessBlock::TileMaterialRefCount, NL3D::ULandscapeTileCallback::tileRemoved(), NL3D::CTileMaterial::TileS, NL3D::CTileMaterial::TileT, uint, and uint64. Referenced by NL3D::CTessFace::releaseTileMaterial(). { nlassert(tm); uint numtb, numtm; computeTbTm(numtb, numtm, tm->TileS, tm->TileT); TessBlocks[numtb].RdrTileRoot[numtm]= NULL; TessBlocks[numtb].FaceTileMaterialRefCount--; TessBlocks[numtb].TileMaterialRefCount--; // The master block contains the whole patch TileMaterialRefCount MasterBlock.TileMaterialRefCount--; // if no more tiles in this tessBlock, delete the vegetable Block. //========== // if no more tiles in this tessBlock if( TessBlocks[numtb].TileMaterialRefCount==0 ) { // release the vegetableBlock (if any) releaseVegetableBlock(numtb); } // Destroy if necessary the TessBlocks. decRefTessBlocks(); // DynamicLighting. When in near, must compute the context, to have good UVs. //========== // dec ref the context, deleting it if needed. decRefDLMContext(); ULandscapeTileCallback *tileCallback = getLandscape()->getTileCallback(); if (tileCallback) { tileCallback->tileRemoved((uint64) tm); // pointer to tile material serves as a unique identifier } }

void NL3D::CPatch::renderFar0 (   )

Render this patch, if not clipped. Call PatchCurrentDriver->renderSimpleTriangles(). Definition at line 528 of file patch_render.cpp. References _PatchRdrPassFar0, NL3D::CTessBlock::Far0FaceVector, isRenderClipped(), MasterBlock, NL3D_PROFILE_LAND_ADD, NL3D_PROFILE_LAND_ADD_FACE_VECTOR, nlassert, NL3D::ProfNPatchRdrFar0, NL3D::ProfNRdrFar0, NL3D::renderFaceVector(), NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, uint, and NL3D::CTessBlock::visibleFar0(). Referenced by NL3D::CLandscape::render(). { NL3D_PROFILE_LAND_ADD(ProfNPatchRdrFar0, 1); #ifdef NL_DEBUG // Must be visible, and must be called only if the RdrPass is enabled. nlassert(!isRenderClipped() && _PatchRdrPassFar0); #endif // Render tris of MasterBlock. renderFaceVector(MasterBlock.Far0FaceVector); // profile NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar0, MasterBlock.Far0FaceVector); // Render tris of TessBlocks. uint nTessBlock= TessBlocks.size(); CTessBlock *pTessBlock= nTessBlock>0? &TessBlocks[0]: NULL ; for(; nTessBlock>0; pTessBlock++, nTessBlock--) { CTessBlock &tblock= *pTessBlock; // if block visible, render if( tblock.visibleFar0() ) { renderFaceVector(tblock.Far0FaceVector); // profile NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar0, tblock.Far0FaceVector); } } }

void NL3D::CPatch::renderFar1 (   )

Definition at line 560 of file patch_render.cpp. References _PatchRdrPassFar1, NL3D::CTessBlock::Far1FaceVector, isRenderClipped(), MasterBlock, NL3D_PROFILE_LAND_ADD, NL3D_PROFILE_LAND_ADD_FACE_VECTOR, nlassert, NL3D::ProfNPatchRdrFar1, NL3D::ProfNRdrFar1, NL3D::renderFaceVector(), NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, uint, and NL3D::CTessBlock::visibleFar1(). Referenced by NL3D::CLandscape::render(). { NL3D_PROFILE_LAND_ADD(ProfNPatchRdrFar1, 1); #ifdef NL_DEBUG // Must be visible, and must be called only if the RdrPass is enabled. nlassert(!isRenderClipped() && _PatchRdrPassFar1); #endif // Render tris of MasterBlock. renderFaceVector(MasterBlock.Far1FaceVector); // profile. NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar1, MasterBlock.Far1FaceVector); // Render tris of TessBlocks. uint nTessBlock= TessBlocks.size(); CTessBlock *pTessBlock= nTessBlock>0? &TessBlocks[0]: NULL ; for(; nTessBlock>0; pTessBlock++, nTessBlock--) { CTessBlock &tblock= *pTessBlock; // if block visible, render if( tblock.visibleFar1() ) { renderFaceVector(tblock.Far1FaceVector); // profile. NL3D_PROFILE_LAND_ADD_FACE_VECTOR(ProfNRdrFar1, tblock.Far1FaceVector); } } }

void NL3D::CPatch::resetCompressedLumels (   )

Rebuild the packed lumels without shadow. Only the interpolated color will be used. See also: packShadowMap(), unpackShadowMap() Definition at line 1384 of file patch_lightmap.cpp. References CompressedLumels, NL_LUMEL_BY_TILE, nlassert, size, and uint. Referenced by NL3D::CZone::build(). { // Number of lumel by lines uint lumelCount=OrderS*NL_LUMEL_BY_TILE; // Number of block in a line nlassert ((lumelCount&0x3)==0); uint numLumelBlock=lumelCount>>2; // Number of line uint lineCount=OrderT*NL_LUMEL_BY_TILE; // Number of block line nlassert ((lineCount&0x3)==0); uint numLineBlock=lineCount>>2; // Size of the lumel array uint size=numLineBlock*numLumelBlock*8; // 4 bits per lumel CompressedLumels.resize (size); // No line have shadows. memset (&CompressedLumels[0], 0, size); }

void NL3D::CPatch::resetMasterBlock (   )  [private]

Definition at line 709 of file patch.cpp. References NL3D::CTessList< CTessFace >::clear(), NL3D::CTessList< CTessFarVertex >::clear(), NL3D::CTessBlock::FarFaceList, NL3D::CTessBlock::FarVertexList, isRenderClipped(), MasterBlock, NL3D::CTessBlock::NearVertexList, nlassert, NumRenderableFaces, and NL3D::CTessList< CTessNearVertex >::size(). Referenced by makeRoots(), and release(). { // We should be not visible so FaceVector no more exist. nlassert(isRenderClipped()); MasterBlock.FarVertexList.clear(); MasterBlock.FarFaceList.clear(); NumRenderableFaces= 0; // no tiles should be here!! nlassert(MasterBlock.NearVertexList.size()==0); }

void NL3D::CPatch::resetRenderFar (   )

Definition at line 1555 of file patch.cpp. References _PatchRdrPassFar0, _PatchRdrPassFar1, NL3D::CLandscape::freeFarRenderPass(), and NL3D::CZone::Landscape. Referenced by release(). { if (_PatchRdrPassFar0) { // free the render pass. Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar0, Far0); _PatchRdrPassFar0= NULL; } if (_PatchRdrPassFar1) { // free the render pass. Zone->Landscape->freeFarRenderPass (this, _PatchRdrPassFar1, Far1); _PatchRdrPassFar1= NULL; } Far0= -1; Far1= -1; }

void NL3D::CPatch::resetTileLightInfluences (   )

make a valid empty array of TileLightInfluences (ie resized to good size, but with empty light influences Definition at line 1529 of file patch_lightmap.cpp. References TileLightInfluences, and uint. Referenced by NL3D::CZone::build(), NL3D::CLandscape::removeAllPointLights(), and serial(). { // Fill default. TileLightInfluences.resize((OrderS/2 +1) * (OrderT/2 +1)); // Disable All light influence on all points for(uint i=0;i <TileLightInfluences.size(); i++) { // Disable all light influence on this point. TileLightInfluences[i].Light[0]= 0xFF; } }

void NL3D::CPatch::serial (  NLMISC::IStream &  f  )

Definition at line 1576 of file patch.cpp. References _CornerSmoothFlag, _Version, NL3D::CTileColor::Color565, CompressedLumels, NLMISC::IStream::isReading(), NL_PATCH_SMOOTH_FLAG_MASK, nlassert, NoiseRotation, resetTileLightInfluences(), NLMISC::IStream::serial(), NLMISC::IStream::serialCont(), NLMISC::IStream::serialVersion(), size, TileColors, TileLightInfluences, Tiles, uint, NLMISC::IStream::xmlPop(), NLMISC::IStream::xmlPush(), and NLMISC::IStream::xmlSerial(). { /* Version 7: - remove unused information from CTileColor. just keep 565 color Version 6: - default UnderWater flags for tileElements before version 6. Version 5: - TileLightInfluences serialized. Version 4: - Smooth flag serialized Version 3: - NoiseRotation. - NoiseSmooth. Version 2: - Lumels. Version 1: - Tile color. Version 0: - base version. */ uint ver= f.serialVersion(_Version); // No more compatibility before version 2, because OrderS / OrderT not serialized in preceding version // Doens't matter since CZone::serial() do not support it too. if (ver<2) { throw EOlderStream(f); } f.xmlSerial (Vertices[0], Vertices[1], Vertices[2], Vertices[3], "VERTICIES"); f.xmlPush ("TANGENTS"); f.serial (Tangents[0], Tangents[1], Tangents[2], Tangents[3]); f.serial (Tangents[4], Tangents[5], Tangents[6], Tangents[7]); f.xmlPop (); f.xmlSerial (Interiors[0], Interiors[1], Interiors[2], Interiors[3], "INTERIORS"); f.xmlPush ("TILES"); f.serialCont(Tiles); f.xmlPop (); if(ver>=1) { // Read/Write TileColors. if(ver<=6) { nlassert(f.isReading()); // read old version of tilesColors (ie with LightX/LightY/LightZ, which are deprecated now) vector<CTileColorOldPatchVersion6> tmpArray; f.xmlPush ("TILE_COLORS"); f.serialCont(tmpArray); f.xmlPop (); // then just copy to TileColors. TileColors.resize(tmpArray.size()); if(TileColors.size()>0) { memcpy(&TileColors[0], &tmpArray[0], TileColors.size()*sizeof(CTileColor)); } } else { // version >=7, just serial array of TileColors (16 bits TileColor only) f.xmlPush ("TILE_COLORS"); f.serialCont(TileColors); #ifdef NEL_FORCE_NO_USER_COLOR CTileColor color; color.Color565 = 0xffff; uint size = TileColors.size (); TileColors.resize (0); TileColors.resize (size, color); #endif // NEL_FORCE_NO_USER_COLOR f.xmlPop (); } } if(ver>=2) { f.xmlSerial (OrderS, "ORDER_S"); f.xmlSerial (OrderT, "ORDER_T"); f.xmlPush ("COMPRESSED_LUMELS"); f.serialCont(CompressedLumels); f.xmlPop (); } // Else cannot create here the TileColors, because we need the OrderS/OrderT information... Done into CZone serial. if(ver>=3) { f.xmlSerial (NoiseRotation, "NOISE_ROTATION"); f.xmlSerial (_CornerSmoothFlag, "CORNER_SMOOTH_FLAG"); } else { // No Rotation / not smooth by default. NoiseRotation= 0; _CornerSmoothFlag= 0; } if(ver>=4) { f.xmlSerial(Flags, "FLAGS"); } else { Flags=NL_PATCH_SMOOTH_FLAG_MASK; } // Serialize TileLightInfluences if(ver>=5) { f.xmlPush ("TILE_LIGHT_INFLUENCES"); f.serialCont(TileLightInfluences); f.xmlPop (); } else { if(f.isReading()) { // Fill default. resetTileLightInfluences(); } } // if read a too old version, if(ver<6 && f.isReading()) { // reset tileElements vegetableState to AboveWater. for(uint i=0; i<Tiles.size(); i++) { Tiles[i].setVegetableState(CTileElement::AboveWater); } } }

void NL3D::CPatch::setCornerSmoothFlag (  uint  corner, bool  smooth )

setup Smooth flags for Noise on corner: used for Noise geometry and for lighting. NB: convention: corner0==A, corner1==B ... Definition at line 951 of file patch_noise.cpp. References _CornerSmoothFlag, nlassert, and uint. Referenced by NL3D::CZone::build(), and NL3D::CZoneCornerSmoother::computeAllCornerSmoothFlags(). { nlassert(corner<=3); uint mask= 1<<corner; if(smooth) _CornerSmoothFlag|= mask; else _CornerSmoothFlag&= ~mask; }

void NL3D::CPatch::setSmoothFlag (  uint  edge, bool  flag )  [inline]

Set the smooth flag for the n-th edge. flag is false if this edge must by smoothed, true else. Definition at line 567 of file patch.h. References NL_PATCH_SMOOTH_FLAG_SHIFT, and uint. { // Erase it Flags&=~(1<<(edge+NL_PATCH_SMOOTH_FLAG_SHIFT)); // Set it Flags|=(((uint)flag)<<(edge+NL_PATCH_SMOOTH_FLAG_SHIFT)); }

void NL3D::CPatch::setupColorsFromTileFlags (  const NLMISC::CRGBA  colors[4]  )

debug coloring Debug purpose only : setup the colors of this patch so that it shows which tiles have vegetable disabled, or are above, below water. User provides a table with 4 colors for each state : color 0 = above water color 1 = underwater color 2 = intersect water color 3 = vegetable disabled Definition at line 2231 of file patch.cpp. References NLMISC::CRGBA::get565(), index, min, s, t, TileColors, Tiles, and uint. { for (uint s = 0; s <= OrderS; ++s) { for (uint t = 0; t <= OrderT; ++t) { uint index = std::min(t, (uint) (OrderT - 1)) * OrderS + std::min(s, (uint) (OrderS - 1)); TileColors[s + t * (OrderS + 1)].Color565 = colors[(uint) (Tiles[index].getVegetableState())].get565(); } } }

void NL3D::CPatch::unbind (   )

unbind the patch from All neighbors. neighbors patchs links are modified too. The tesselation is forcemerged. Definition at line 1724 of file patch.cpp. References _BindZoneNeighbor, NL3D::CTessFace::FLeft, NL3D::CTessFace::forceMerge(), NL3D::CTessFace::FRight, NL3D::CTessFace::isLeaf(), nlassert, Son0, Son1, and NL3D::CTessFace::unbind(). Referenced by NL3D::CZone::bindPatch(), and NL3D::CZone::unbindPatch(). { nlassert(Son0 && Son1); Son0->unbind(); Son1->unbind(); Son0->forceMerge(); Son1->forceMerge(); // forcemerge should have be completed. nlassert(Son0->isLeaf() && Son1->isLeaf()); // unbind should have be completed. nlassert(Son0->FLeft == NULL); nlassert(Son0->FRight == NULL); nlassert(Son1->FLeft == NULL); nlassert(Son1->FRight == NULL); // unbind Noise. _BindZoneNeighbor[0]= NULL; _BindZoneNeighbor[1]= NULL; _BindZoneNeighbor[2]= NULL; _BindZoneNeighbor[3]= NULL; }

void NL3D::CPatch::unlinkNearUL (   )

For lighting update, unlink (CiruclarList). Definition at line 1897 of file patch_lightmap.cpp. References _ULNearNext, and _ULNearPrec. Referenced by NL3D::CLandscape::unlinkPatchFromNearUL(). { // first, unlink others from me. NB: works even if _ULNearPrec==_ULNearNext==this. _ULNearNext->_ULNearPrec= _ULNearPrec; _ULNearPrec->_ULNearNext= _ULNearNext; // reset _ULNearPrec= this; _ULNearNext= this; }

void NL3D::CPatch::unpack (  CBezierPatch &  p  )  const

Definition at line 192 of file patch.cpp. References NL3D::CZone::getPatchBias(), NL3D::CZone::getPatchScale(), NL3D::CBezierPatch::Interiors, sint, NL3D::CBezierPatch::Tangents, NL3D::CVector3s::unpack(), and NL3D::CBezierPatch::Vertices. Referenced by unpackIntoCache(). { sint i; const CVector &bias= Zone->getPatchBias(); float scale= Zone->getPatchScale(); for(i=0;i<4;i++) Vertices[i].unpack(p.Vertices[i], bias, scale); for(i=0;i<8;i++) Tangents[i].unpack(p.Tangents[i], bias, scale); for(i=0;i<4;i++) Interiors[i].unpack(p.Interiors[i], bias, scale); }

CBezierPatch * NL3D::CPatch::unpackIntoCache (   )  const

Definition at line 182 of file patch.cpp. References CachePatch, LastPatch, and unpack(). Referenced by addPatchBlocksInBBox(), addTrianglesInBBox(), appendTileMaterialToRenderList(), buildBBox(), NL3D::CZoneLighter::buildZoneInformation(), computeDefaultErrorSize(), computeNoise(), computeNormalCornerSmooth(), computeNormalEdgeSmooth(), computeNormalOnNeighbor(), computeVertex(), createVegetableBlock(), NL3D::CPatchDLMContext::generate(), generateTileVegetable(), NL3D::CLandscapeVegetableBlock::init(), and NL3D::CZoneLighter::processZonePointLightRT(). { if(LastPatch!=this) { unpack(CachePatch); LastPatch=this; } return &CachePatch; }

void NL3D::CPatch::unpackLumelBlock (  uint8 *  dest, const uint8 *  src )  [private]

Unpack a 4x4 lumel block See also: packShadowMap(), unpackShadowMap() Definition at line 70 of file patch_lightmap.cpp. References src, uint, and uint8. Referenced by computeTileLightmapPrecomputed(), getTileLumelmapPrecomputed(), packShadowMap(), and unpackShadowMap(). { // Take the two alpha values uint alpha0=src[0]; uint alpha1=src[1]; // precompute the 8 possible values, for each possible code. // ------------------ uint8 values[8]; // Case 0 if (alpha0>alpha1) { // unrolled, and hardcoded for faster compute values[0]= alpha0; values[1]= alpha1; values[2]= (uint8) ( (alpha0*219 + alpha1*37 ) >>8 ) ; // 6*256/7 values[3]= (uint8) ( (alpha0*183 + alpha1*73 ) >>8 ) ; // 5*256/7 values[4]= (uint8) ( (alpha0*146 + alpha1*110) >>8 ) ; // 4*256/7 values[5]= (uint8) ( (alpha0*110 + alpha1*146) >>8 ) ; // 3*256/7 values[6]= (uint8) ( (alpha0*73 + alpha1*183) >>8 ) ; // 2*256/7 values[7]= (uint8) ( (alpha0*37 + alpha1*219) >>8 ) ; // 1*256/7 } // Case 1 else { // unrolled, and hardcoded for faster compute values[0]= alpha0; values[1]= alpha1; values[2]= (uint8) ( (alpha0*205 + alpha1*51 ) >>8 ) ; // 4*256/5 values[3]= (uint8) ( (alpha0*154 + alpha1*102) >>8 ) ; // 3*256/5 values[4]= (uint8) ( (alpha0*102 + alpha1*154) >>8 ) ; // 2*256/5 values[5]= (uint8) ( (alpha0*51 + alpha1*205) >>8 ) ; // 1*256/5 values[6]= 0; values[7]= 255; } // For each pixel, set the value according to the code // ------------------ uint block8Pixs[2]; // Split the 48 bits data in 2 24 bits pass. block8Pixs[0]= ((uint)src[2]<<16) + ((uint)src[3]<<8) + ((uint)src[4]) ; block8Pixs[1]= ((uint)src[5]<<16) + ((uint)src[6]<<8) + ((uint)src[7]) ; // write all lumels for(uint i=0; i<2; i++) { uint blockPix= block8Pixs[i]; // parse the 8 pixs, and write seq to dest for(uint n=8; n>0; n--, dest++) { uint code= (blockPix>>21)&0x7; // read LUT, and store *dest= values[code]; // shift the block blockPix<<= 3; } } }

void NL3D::CPatch::unpackShadowMap (  uint8 *  pShadow  )

Unpack the lumels of the patches. Lumels are classes that describe the lighting environnement at a given texel of the lightmap. It is used to compute the shadow map of the patch, compress it and uncompress it. This method uncompress the lumels stored in its Lumels member. Parameters: pShadow  is a pointer on the destination lumel buffer. Size must be ((OrderS*4/ratio)+1)*((OrderT*4/ratio)+1). ratio  is the one over the ratio of the texture destination. Must be 1 or 2. See also: packShadowMap(), resetCompressedLumels() Definition at line 170 of file patch_lightmap.cpp. References CompressedLumels, NL_BLOCK_LUMEL_COMPRESSED_SIZE, NL_LUMEL_BY_TILE, nlassert, uint, uint8, unpackLumelBlock(), and v. Referenced by NL3D::CTextureFar::rebuildPatch(), and NL3D::CZone::retrieve(). { // Input of compresed data uint8 *compressedData=&CompressedLumels[0]; // Number of lumel by lines uint lumelCount=OrderS*NL_LUMEL_BY_TILE; // Number of block in a line nlassert ((lumelCount&0x3)==0); uint numLumelBlock=lumelCount>>2; // Number of line uint lineCount=OrderT*NL_LUMEL_BY_TILE; // Number of block line nlassert ((lineCount&0x3)==0); uint numLineBlock=lineCount>>2; // Destination lumel block size uint lumelDestBlockSize=4; // Destination lumel line block size uint lumelDestLineBlockSize=lumelCount*lumelDestBlockSize; // Each line block for (uint lineBlock=0; lineBlock<numLineBlock; lineBlock++) { uint countVx4=16; // Block pointer uint8 *blockLine=pLumelDest; // Each lumel block for (uint lumelBlock=0; lumelBlock<numLumelBlock; lumelBlock++) { // *** Unpack the block uint countU=4; // Destination lumel uint8 *blockDest=blockLine; // Temp block uint8 block[4*4]; // Block unpacking... unpackLumelBlock (block, compressedData); // Copy the lumels for (uint v=0; v<countVx4; v+=4) { for (uint u=0; u<countU; u++) { // Copy the lumel blockDest[u]=block[v+u]; } // Next line blockDest+=lumelCount; } // Next source block compressedData+=NL_BLOCK_LUMEL_COMPRESSED_SIZE; // Next block on the line blockLine+=lumelDestBlockSize; } // Next line of block pLumelDest+=lumelDestLineBlockSize; } }

void NL3D::CPatch::updateClipPatchVB (  bool  renderClipped  )

Definition at line 1464 of file patch_render.cpp. References allocateVBAndFaceVector(), deleteVBAndFaceVector(), NLMISC::CObjectVector< CTessBlock >::empty(), fillVB(), NL3D::CTessBlock::forceClip(), NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. { // If now the patch is invisible if(renderClipped) { // Then delete vertices. deleteVBAndFaceVector(); // Now, all vertices in VB are deleted. // Force clip state of all TessBlocks, so no allocation will be done on Vertices in VB. if(!TessBlocks.empty()) { for(uint i=0; i<TessBlocks.size();i++) { CTessBlock &tblock= TessBlocks[i]; tblock.forceClip(); } } } else { // else allocate / fill them. allocateVBAndFaceVector(); // NB: fillVB() test if any reallocation occurs. fillVB(); } }

void NL3D::CPatch::updateFar0VBAlloc (  CTessList< CTessFarVertex > &  vertList, bool  alloc )  [private]

Definition at line 744 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessFarVertex::Index0, and NL3D::CTessNodeList::Next. Referenced by preRender(), and updateVBAlloc(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { if(alloc) pVert->Index0= CLandscapeGlobals::CurrentFar0VBAllocator->allocateVertex(); else CLandscapeGlobals::CurrentFar0VBAllocator->deleteVertex(pVert->Index0); } }

void NL3D::CPatch::updateFar1VBAlloc (  CTessList< CTessFarVertex > &  vertList, bool  alloc )  [private]

Definition at line 759 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessFarVertex::Index1, and NL3D::CTessNodeList::Next. Referenced by allocateVBAndFaceVectorFar1Only(), deleteVBAndFaceVectorFar1Only(), preRender(), and updateVBAlloc(). { // Traverse the vertList. CTessFarVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessFarVertex*)pVert->Next) { if(alloc) pVert->Index1= CLandscapeGlobals::CurrentFar1VBAllocator->allocateVertex(); else CLandscapeGlobals::CurrentFar1VBAllocator->deleteVertex(pVert->Index1); } }

uint NL3D::CPatch::updateTessBlockLighting (  uint  numTb  )

recompute the near lightmap of tessBlock "numTb". return the number of pixels updated by computing of this tessBlock. Actually 0 if the tessBlock lightmap is not computed, or 100 (NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE) pixels. Definition at line 1909 of file patch_lightmap.cpp. References computeNearBlockLightmap(), NL3D::CZone::Landscape, NL3D::CTessBlock::LightMapId, NL3D::CTessBlock::LightMapRefCount, NL_TILE_LIGHTMAP_SIZE, nlassert, NL3D::CLandscape::refillTileLightMap(), NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, and uint. Referenced by NL3D::CLandscape::updateLightingTextureNear(). { // TessBlocks must have been allocated and tessBlockId must be ok. nlassert(numTb<TessBlocks.size()); // compute tessBlock coordinate uint tbWidth= OrderS>>1; uint ts= numTb&(tbWidth-1); uint tt= numTb/tbWidth; // expand to tile coordinate. ts*= 2; tt*= 2; // get what tessBlock to use. CTessBlock &tessBlock= TessBlocks[numTb]; // If the lightmap Id has not been computed, quit if(tessBlock.LightMapRefCount==0) return 0; else { // Recompute the lightmap texture, with help of TileColors, with neighboring info etc... CRGBA lightText[NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE]; computeNearBlockLightmap(ts&(~1), tt&(~1), lightText); // donlod this texture to Driver etc... Zone->Landscape->refillTileLightMap(tessBlock.LightMapId, lightText); // return number of pixels computed. return NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE; } }

void NL3D::CPatch::updateTextureFarOnly (  const NLMISC::CBSphere &  patchSphere  )

Definition at line 226 of file patch_render.cpp. References computeNewFar(), and sint. { sint newFar0,newFar1; // compute new Far0 and new Far1. computeNewFar(patchSphere, newFar0, newFar1); // Far change. //------------------ // Set new far values Far0= newFar0; Far1= newFar1; }

void NL3D::CPatch::updateTileVBAlloc (  CTessList< CTessNearVertex > &  vertList, bool  alloc )  [private]

Definition at line 774 of file patch_render.cpp. References NL3D::CTessList< T >::begin(), NL3D::CTessNearVertex::Index, and NL3D::CTessNodeList::Next. Referenced by preRender(), and updateVBAlloc(). { // Traverse the vertList. CTessNearVertex *pVert; for(pVert= vertList.begin(); pVert; pVert= (CTessNearVertex*)pVert->Next) { if(alloc) pVert->Index= CLandscapeGlobals::CurrentTileVBAllocator->allocateVertex(); else CLandscapeGlobals::CurrentTileVBAllocator->deleteVertex(pVert->Index); } }

void NL3D::CPatch::updateVBAlloc (  bool  alloc  )  [private]

Definition at line 789 of file patch_render.cpp. References NL3D::CTessBlock::FarVertexList, MasterBlock, NL3D::CTessBlock::NearVertexList, sint, NLMISC::CObjectVector< CTessBlock >::size(), TessBlocks, updateFar0VBAlloc(), updateFar1VBAlloc(), updateTileVBAlloc(), NL3D::CTessBlock::visibleFar0(), NL3D::CTessBlock::visibleFar1(), and NL3D::CTessBlock::visibleTile(). Referenced by allocateVBAndFaceVector(), and deleteVBAndFaceVector(). { // update Far0. //======= if(Far0>0) { // alloc Far0 VB. updateFar0VBAlloc(MasterBlock.FarVertexList, alloc); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // need update VB only if tessBlock is visible. if( tblock.visibleFar0() ) updateFar0VBAlloc(tblock.FarVertexList, alloc); } } else if (Far0==0) { // alloc Tile VB. // No Tiles in MasterBlock!! // Traverse the TessBlocks to add vertices. for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // Add the vertices. // need update VB only if tessBlock is visible. if( tblock.visibleTile() ) updateTileVBAlloc(tblock.NearVertexList, alloc); } } // update Far1. //======= if(Far1>0) { // alloc VB. updateFar1VBAlloc(MasterBlock.FarVertexList, alloc); for(sint i=0; i<(sint)TessBlocks.size(); i++) { CTessBlock &tblock= TessBlocks[i]; // need update VB only if tessBlock is visible. if( tblock.visibleFar1() ) updateFar1VBAlloc(tblock.FarVertexList, alloc); } } }

---

Friends And Related Function Documentation

friend class CLandscapeVegetableBlock [friend]

Definition at line 796 of file patch.h.

friend class CPatchRdrPass [friend]

Definition at line 797 of file patch.h.

friend class CTessFace [friend]

Definition at line 794 of file patch.h.

friend class CZone [friend]

Definition at line 795 of file patch.h.

---

Field Documentation

CZone* NL3D::CPatch::_BindZoneNeighbor[4] [private]

The 4 neighbors zone of this patch (setuped at bind() time). NB: NULL if zone not loaded, or if no patch near us. Definition at line 1110 of file patch.h. Referenced by bind(), CPatch(), getBindNeighbor(), and unbind().

uint8 NL3D::CPatch::_CornerSmoothFlag [private]

Put here for packing with NoiseRotation. Definition at line 362 of file patch.h. Referenced by CPatch(), getCornerSmoothFlag(), serial(), and setCornerSmoothFlag().

CPatchDLMContext* NL3D::CPatch::_DLMContext [private]

The Dynamic LightMap context. created only when compiled, AND (when in Near OR (when in Far AND touched by pointLight)) else NULL. Definition at line 1214 of file patch.h. Referenced by addRefDLMContext(), beginDLMLighting(), CPatch(), decRefDLMContext(), endDLMLighting(), fillFar0DLMUvOnlyVertexListVB(), fillFar0VertexVB(), fillFar1DLMUvOnlyVertexListVB(), fillFar1VertexVB(), generateTileVegetable(), NL3D::CTessFace::initTileUvDLM(), processDLMLight(), and release().

sint NL3D::CPatch::_DLMContextRefCount [private]

The reference count for DLMContext. Each TileMaterial created add a reference. Each pointLight wich touch the patch too. Definition at line 1219 of file patch.h. Referenced by addRefDLMContext(), CPatch(), decRefDLMContext(), and release().

CPatch* NL3D::CPatch::_NextRdrFar0 [private]

Definition at line 872 of file patch.h. Referenced by NL3D::CPatchRdrPass::appendRdrPatchFar0(), CPatch(), and getNextFar0ToRdr().

CPatch* NL3D::CPatch::_NextRdrFar1 [private]

Definition at line 874 of file patch.h. Referenced by NL3D::CPatchRdrPass::appendRdrPatchFar1(), CPatch(), and getNextFar1ToRdr().

CPatchRdrPass* NL3D::CPatch::_PatchRdrPassFar0 [private]

Definition at line 871 of file patch.h. Referenced by computeNewFar(), CPatch(), preRender(), renderFar0(), and resetRenderFar().

CPatchRdrPass* NL3D::CPatch::_PatchRdrPassFar1 [private]

Definition at line 873 of file patch.h. Referenced by computeNewFar(), CPatch(), preRender(), renderFar1(), and resetRenderFar().

CPatch* NL3D::CPatch::_ULNearNext [private]

Definition at line 1203 of file patch.h. Referenced by compile(), CPatch(), getNextNearUL(), linkBeforeNearUL(), release(), and unlinkNearUL().

CPatch* NL3D::CPatch::_ULNearPrec [private]

Definition at line 1202 of file patch.h. Referenced by compile(), CPatch(), linkBeforeNearUL(), release(), and unlinkNearUL().

uint32 NL3D::CPatch::_Version = 7 [static, private]

Stream version of the class. Definition at line 57 of file patch.cpp. Referenced by serial().

CTessFarVertex NL3D::CPatch::BaseFarVertices[4] [private]

Definition at line 822 of file patch.h. Referenced by makeRoots().

CTessVertex* NL3D::CPatch::BaseVertices[4] [private]

Definition at line 820 of file patch.h. Referenced by averageTesselationVertices(), bind(), compile(), computeContinousVertex(), computeVertexButCorner(), getCornerVertex(), makeRoots(), and refreshTesselationGeometry().

CBezierPatch NL3D::CPatch::CachePatch [static, private]

Definition at line 55 of file patch.cpp. Referenced by unpackIntoCache().

std::vector<uint8> NL3D::CPatch::CompressedLumels

Definition at line 337 of file patch.h. Referenced by computeTileLightmapEdgePrecomputed(), computeTileLightmapPixelPrecomputed(), computeTileLightmapPrecomputed(), getTileLumelmapPixelPrecomputed(), getTileLumelmapPrecomputed(), packShadowMap(), resetCompressedLumels(), serial(), and unpackShadowMap().

float NL3D::CPatch::ErrorSize [private]

Definition at line 816 of file patch.h. Referenced by compile(), computeDefaultErrorSize(), getErrorSize(), and makeRoots().

bool NL3D::CPatch::ExcludeFromRefineAll [private]

Definition at line 807 of file patch.h. Referenced by CPatch(), and NL3D::CZone::refineAll().

sint NL3D::CPatch::Far0 [private]

Definition at line 867 of file patch.h.

float NL3D::CPatch::Far0UBias [private]

Definition at line 827 of file patch.h. Referenced by computeNewFar(), and fillFar0VertexVB().

float NL3D::CPatch::Far0UScale [private]

Definition at line 827 of file patch.h. Referenced by computeNewFar(), and fillFar0VertexVB().

float NL3D::CPatch::Far0VBias [private]

Definition at line 827 of file patch.h. Referenced by computeNewFar(), and fillFar0VertexVB().

float NL3D::CPatch::Far0VScale [private]

Definition at line 827 of file patch.h. Referenced by computeNewFar(), and fillFar0VertexVB().

sint NL3D::CPatch::Far1 [private]

Definition at line 868 of file patch.h.

float NL3D::CPatch::Far1UBias [private]

Definition at line 828 of file patch.h. Referenced by computeNewFar(), and fillFar1VertexVB().

float NL3D::CPatch::Far1UScale [private]

Definition at line 828 of file patch.h. Referenced by computeNewFar(), and fillFar1VertexVB().

float NL3D::CPatch::Far1VBias [private]

Definition at line 828 of file patch.h. Referenced by computeNewFar(), and fillFar1VertexVB().

float NL3D::CPatch::Far1VScale [private]

Definition at line 828 of file patch.h. Referenced by computeNewFar(), and fillFar1VertexVB().

uint8 NL3D::CPatch::Flags [private]

Flags NL_PATCH_FAR0_ROTATED and NL_PATCH_FAR1_ROTATED NL_PATCH_FAR0_ROTATED for Far0, NL_PATCH_FAR1_ROTATED for Far1 If the flag is set, the far texture of the patch is rotated of 1 (to the left of course) Flags NL_PATCH_SMOOTH_FLAG_MASK 4 flag for smooth edge. Same as CPatchInfo::CBindInfo shifted by (<<NL_PATCH_SMOOTH_FLAG_SHIFT). See CPatchInfo::CBindInfo::Flags for details. Definition at line 840 of file patch.h. Referenced by NL3D::CZone::build(), and NL3D::CZone::retrieve().

CVector3s NL3D::CPatch::Interiors[4]

Definition at line 329 of file patch.h. Referenced by NL3D::CZone::applyHeightField(), NL3D::CZone::build(), and NL3D::CZone::retrieve().

const CPatch * NL3D::CPatch::LastPatch = NULL [static, private]

Definition at line 56 of file patch.cpp. Referenced by unpackIntoCache().

CTessBlock NL3D::CPatch::MasterBlock [private]

Definition at line 884 of file patch.h. Referenced by allocateVBAndFaceVectorFar1Only(), appendFaceToRenderList(), appendFarVertexToRenderList(), appendTileMaterialToRenderList(), compile(), computeSoftwareGeomorphAndAlpha(), CPatch(), createFaceVectorFar0OrTile(), createFaceVectorFar1(), debugAllocationMarkIndices(), deleteFaceVectorFar0OrTile(), deleteFaceVectorFar1(), deleteVBAndFaceVectorFar1Only(), fillVB(), fillVBFar0Only(), fillVBFar1Only(), fillVBFarsDLMUvOnly(), getTileMaterialRefCount(), recreateTessBlockFaceVector(), removeFaceFromRenderList(), removeFarVertexFromRenderList(), removeTileMaterialFromRenderList(), renderFar0(), renderFar1(), resetMasterBlock(), and updateVBAlloc().

uint8 NL3D::CPatch::NoiseRotation

The orientation of the NoiseMap. 0,1,2,3. This represent a CCW rotation of the NoiseMap. Definition at line 352 of file patch.h. Referenced by NL3D::CZone::build(), computeDisplaceRawCoordinates(), CPatch(), NL3D::CZone::retrieve(), and serial().

sint NL3D::CPatch::NumRenderableFaces [private]

Definition at line 879 of file patch.h. Referenced by appendFaceToRenderList(), NL3D::CPatchRdrPass::appendRdrPatchFar0(), NL3D::CPatchRdrPass::appendRdrPatchFar1(), CPatch(), preRender(), removeFaceFromRenderList(), and resetMasterBlock().

float NL3D::CPatch::OOTransitionSqrDelta [private]

Definition at line 845 of file patch.h. Referenced by computeGeomorphAlphaFar1VertexListVB(), computeNewFar(), and fillFar1VertexVB().

uint8 NL3D::CPatch::OrderS [private]

Definition at line 804 of file patch.h. Referenced by bind(), NL3D::CZone::build(), NL3D::CZone::compile(), NL3D::CTessFace::computeTileMaterial(), and NL3D::CZone::retrieve().

uint8 NL3D::CPatch::OrderT [private]

Definition at line 804 of file patch.h. Referenced by bind(), NL3D::CZone::build(), NL3D::CZone::compile(), NL3D::CTessFace::computeTileMaterial(), and NL3D::CZone::retrieve().

uint16 NL3D::CPatch::PatchId [private]

Definition at line 802 of file patch.h.

CTessFace* NL3D::CPatch::Son0 [private]

Definition at line 818 of file patch.h. Referenced by appendTessellationLeaves(), averageTesselationVertices(), bind(), changeEdgeNeighbor(), CPatch(), deleteTileUvs(), forceMergeAtTileLevel(), getRootFaceForEdge(), getRootVertexForEdge(), getTesselatedPos(), linkTessFaceWithEdge(), makeRoots(), recreateTileUvs(), refineAll(), refreshTesselationGeometry(), release(), and unbind().

CTessFace * NL3D::CPatch::Son1 [private]

Definition at line 818 of file patch.h. Referenced by appendTessellationLeaves(), averageTesselationVertices(), bind(), changeEdgeNeighbor(), CPatch(), deleteTileUvs(), forceMergeAtTileLevel(), getRootFaceForEdge(), getRootVertexForEdge(), getTesselatedPos(), linkTessFaceWithEdge(), makeRoots(), recreateTileUvs(), refineAll(), refreshTesselationGeometry(), release(), and unbind().

sint NL3D::CPatch::SquareLimitLevel [private]

Definition at line 814 of file patch.h. Referenced by compile(), and NL3D::CTessFace::isRectangular().

CVector3s NL3D::CPatch::Tangents[8]

Definition at line 328 of file patch.h. Referenced by NL3D::CZone::applyHeightField(), NL3D::CZone::build(), and NL3D::CZone::retrieve().

sint NL3D::CPatch::TessBlockLimitLevel [private]

Definition at line 810 of file patch.h. Referenced by appendFaceToRenderList(), compile(), extendTessBlockWithEndPos(), and removeFaceFromRenderList().

sint NL3D::CPatch::TessBlockRefCount [private]

Definition at line 886 of file patch.h. Referenced by addRefTessBlocks(), clearTessBlocks(), CPatch(), and decRefTessBlocks().

NLMISC::CObjectVector<CTessBlock> NL3D::CPatch::TessBlocks [private]

Definition at line 882 of file patch.h. Referenced by addRefTessBlocks(), allocateVBAndFaceVectorFar1Only(), appendFaceToRenderList(), appendFaceToTileRenderList(), appendFarVertexToRenderList(), appendNearVertexToRenderList(), appendTileMaterialToRenderList(), clearTessBlocks(), computeSoftwareGeomorphAndAlpha(), createFaceVectorFar0OrTile(), createFaceVectorFar1(), createVegetableBlock(), debugAllocationMarkIndices(), deleteAllVegetableIgs(), deleteFaceVectorFar0OrTile(), deleteFaceVectorFar1(), deleteVBAndFaceVectorFar1Only(), extendTessBlockWithEndPos(), fillVB(), fillVBFar0Only(), fillVBFar1Only(), fillVBFarsDLMUvOnly(), getNumNearTessBlocks(), getTileLightMap(), getTileLightMapUvInfo(), preRender(), recreateAllVegetableIgs(), recreateTileUvs(), releaseTileLightMap(), releaseVegetableBlock(), removeFaceFromRenderList(), removeFaceFromTileRenderList(), removeFarVertexFromRenderList(), removeNearVertexFromRenderList(), removeTileMaterialFromRenderList(), renderFar0(), renderFar1(), updateClipPatchVB(), updateTessBlockLighting(), and updateVBAlloc().

std::vector<CTileColor> NL3D::CPatch::TileColors

Definition at line 343 of file patch.h. Referenced by NL3D::CZone::build(), NL3D::CPatchDLMContext::compileLighting(), NL3D::CPatchDLMContext::computeTextureFar(), NL3D::CPatchDLMContext::generate(), getTileTileColors(), NL3D::CTextureFar::rebuildPatch(), NL3D::CZone::retrieve(), serial(), and setupColorsFromTileFlags().

std::vector<CTileLightInfluence> NL3D::CPatch::TileLightInfluences

Definition at line 346 of file patch.h. Referenced by appendTileLightInfluences(), NL3D::CZone::build(), resetTileLightInfluences(), NL3D::CZone::retrieve(), and serial().

sint NL3D::CPatch::TileLimitLevel [private]

Definition at line 812 of file patch.h. Referenced by compile(), NL3D::CTessFace::computeNearLimit(), NL3D::CTessFace::computeTileMaterial(), NL3D::CTessFace::deleteTileUvs(), NL3D::CTessFace::doMerge(), NL3D::CTessFace::forceMergeAtTileLevel(), NL3D::CTessFace::recreateTileUvs(), NL3D::CTessFace::refineAll(), NL3D::CTessFace::releaseTileMaterial(), NL3D::CTessFace::split(), NL3D::CTessFace::splitRectangular(), NL3D::CTessFace::updateErrorMetric(), NL3D::CTessFace::updateRefineMerge(), and NL3D::CTessFace::updateRefineSplit().

std::vector<CTileElement> NL3D::CPatch::Tiles

Definition at line 340 of file patch.h. Referenced by NL3D::CZone::build(), computeDisplaceRawInteger(), NL3D::CPatchDLMContext::computeTextureFar(), copyTileFlagsFromPatch(), generateTileVegetable(), getTileElement(), getTileRenderPass(), getTileUvInfo(), NL3D::CTextureFar::rebuildPatch(), NL3D::CZone::retrieve(), serial(), and setupColorsFromTileFlags().

float NL3D::CPatch::TransitionSqrMin [private]

Definition at line 844 of file patch.h. Referenced by computeGeomorphAlphaFar1VertexListVB(), computeNewFar(), and fillFar1VertexVB().

std::vector<CVegetableClipBlock*> NL3D::CPatch::VegetableClipBlocks [private]

list of vegetable clipBlocks, created/destroyed at same time as TessBlocks. Definition at line 893 of file patch.h. Referenced by addRefTessBlocks(), clearTessBlocks(), and createVegetableBlock().

CVector3s NL3D::CPatch::Vertices[4]

The patch coordinates (see CBezierPatch). Definition at line 327 of file patch.h. Referenced by NL3D::CZone::applyHeightField(), NL3D::CZone::build(), and NL3D::CZone::retrieve().

CZone* NL3D::CPatch::Zone [private]

Definition at line 799 of file patch.h.

---

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

• patch.h
• patch.cpp
• patch_lightmap.cpp
• patch_noise.cpp
• patch_render.cpp
• patch_vegetable.cpp

---