NL3D::CVegetableManager Class Reference

#include <vegetable_manager.h>

---

Detailed Description

Manager of vegetable. Instance Factory and rendering. A VegetableManager should be put into a CScene model which is Opaque (ie rendered in Opaque pass), and call vegetableManager::render() at this time. a good example is CLandscape.

Because during render(), it uses and setup special "Vegetable Blend Layer models" to render transparents alpha blended vegetables. Toses models are transparent so they are drawn during the transparent pass of the renderTrav's CScene (so after the Opaque pass).

Author:

Lionel Berenguier

Nevrax France

Date:

2001

Definition at line 75 of file vegetable_manager.h.

UpdateLighting management
void	doUpdateLighting ()
	update lighting according to _ULNVerticesToUpdate
uint	updateInstanceLighting (CVegetableInstanceGroup *ig, uint rdrPassId, uint instanceId)
bool	updateLightingIGPart ()
uint	_ULCurrentIgInstance
	update lighting according to _ULNVerticesToUpdate
uint	_ULCurrentIgRdrPass
	Current instance to render in the first ig to update: rdrpass/instanceId.
float	_ULFrequency
	Frequency of update.
uint	_ULNTotalVertices
	Sum of all ig vertices to update.
float	_ULNVerticesToUpdate
	Current number of vertices to update. If negative, I have some advance.
double	_ULPrecTime
bool	_ULPrecTimeInit
	update lighting according to _ULNVerticesToUpdate
CVegetableInstanceGroup *	_ULRootIg
	the priority list of ig to update
double	_ULTime
	update lighting according to _ULNVerticesToUpdate
CVegetableBlendLayerModel mgt.
void	exitRenderStateForBlendLayerModel (IDriver *driver)
void	setupRenderStateForBlendLayerModel (IDriver *driver)
	called by CVegetableBlendLayerModel.
uint	_NumZSortBlendLayers
	For Alpha Blend rdrPass, ordering into layers.
float	_ZSortLayerDistMax
std::vector< CVegetableBlendLayerModel * >	_ZSortModelLayers
std::vector< CVegetableBlendLayerModel * >	_ZSortModelLayersUW
CScene *	_ZSortScene
Public Types
enum	TVegetableWater { AboveWater = 0, UnderWater, IntersectWater, VegetInfoLast }
	Micro vegetation position against Water. Above water is the default. More...
Public Member Functions
void	createVegetableBlendLayersModels (CScene *scene)
	CVegetableManager (uint maxVertexVbHardUnlit, uint maxVertexVbHardLighted, uint nbBlendLayers=20, float blendLayerDistMax=60.f)
	~CVegetableManager ()
Adding Instances to an Ig.
void	addInstance (CVegetableInstanceGroup *ig, CVegetableShape *shape, const NLMISC::CMatrix &mat, const NLMISC::CRGBAF &ambientColor, const NLMISC::CRGBAF &diffuseColor, float bendFactor, float bendPhase, float bendFreqFactor, float blendDistMax, TVegetableWater vegetWaterState, CVegetableUV8 dlmUV)
void	reserveIgAddInstances (CVegetableInstanceGroupReserve &vegetIgReserve, CVegetableShape *shape, TVegetableWater vegetWaterState, uint numInstances)
void	reserveIgCompile (CVegetableInstanceGroup *ig, const CVegetableInstanceGroupReserve &vegetIgReserve)
instance management
CVegetableClipBlock *	createClipBlock ()
	Create a clipBlock where SortBlock will be created.
CVegetableInstanceGroup *	createIg (CVegetableSortBlock *sortBlock)
CVegetableSortBlock *	createSortBlock (CVegetableClipBlock *clipBlock, const CVector &center, float radius)
void	deleteClipBlock (CVegetableClipBlock *clipBlock)
	delete such a clipBlock. all sortBlocks and so all ig must be deleted before.
void	deleteIg (CVegetableInstanceGroup *ig)
void	deleteSortBlock (CVegetableSortBlock *sortBlock)
	delete such a SortBlock. all ig must be deleted before.
Profile
uint	getNumVegetableFaceRendered () const
	get the number of faces rendered by the vegetable manager
void	resetNumVegetableFaceRendered ()
	set to 0 the number of faces rendered
Shape management
CVegetableShape *	getVegetableShape (const std::string &shape)
	Load a shape if necessary, and return a shapeId for this shape.
render
void	loadTexture (ITexture *itex)
	setup a global texture used for all vegetables (smartPtr-ized).
void	loadTexture (const std::string &texName)
	load a global texture used for all vegetables (lookup into CPath).
void	lockBuffers ()
void	render (const CVector &viewCenter, const CVector &frontVector, const std::vector< CPlane > &pyramid, ITexture *textureDLM, IDriver *driver)
void	setDirectionalLight (const CRGBA &ambient, const CRGBA &diffuse, const CVector &light)
	setup the directional light
void	unlockBuffers ()
	unlock any AGP vertex buffers
void	updateDriver (IDriver *driver)
	must give a driver to the vegetableManager, before any addInstance().
Wind animation
void	setTime (double time)
void	setWind (const CVector &windDir, float windFreq, float windPower, float windBendMin)
UpdateLighting management
void	setUpdateLightingFrequency (float freq)
void	setUpdateLightingTime (double time)
void	updateLighting ()
void	updateLightingAll ()
Private Types
typedef TShapeMap::iterator	ItShapeMap
typedef std::map< std::string, CVegetableShape >	TShapeMap
Private Member Functions
uint	getRdrPassInfoForShape (CVegetableShape *shape, TVegetableWater vegetWaterState, bool &instanceLighted, bool &instanceDoubleSided, bool &instanceZSort, bool &destLighted, bool &precomputeLighting)
	get the rdrPass and other info for a given shape.
CVegetableVBAllocator &	getVBAllocatorForRdrPassAndVBHardMode (uint rdrPass, uint vbHardMode)
	Get the good allocator for the appropriate rdr pass.
void	initVertexProgram (uint vpType)
	init the ith vertexProgram.
void	setupVertexProgramConstants (IDriver *driver)
	setup the vertexProgram constants.
void	swapIgRdrPassHardMode (CVegetableInstanceGroup *, uint rdrPass)
Static Private Member Functions
bool	doubleSidedRdrPass (uint rdrPass)
Private Attributes
CTessList< CVegetableClipBlock >	_ClipBlockList
NLMISC::CBlockMemory< CVegetableClipBlock >	_ClipBlockMemory
CVector	_DirectionalLight
CTessList< CVegetableClipBlock >	_EmptyClipBlockList
NLMISC::CRGBA	_GlobalAmbient
NLMISC::CRGBA	_GlobalDiffuse
NLMISC::CBlockMemory< CVegetableInstanceGroup >	_InstanceGroupMemory
NLMISC::CRefPtr< IDriver >	_LastDriver
uint	_NumVegetableFaceRendered
	profile
TShapeMap	_ShapeMap
NLMISC::CBlockMemory< CVegetableSortBlock >	_SortBlockMemory
CVegetableVBAllocator	_VBHardAllocator [CVegetableVBAllocator::VBTypeCount]
CVegetableVBAllocator	_VBSoftAllocator [CVegetableVBAllocator::VBTypeCount]
CMaterial	_VegetableMaterial
CVertexProgram *	_VertexProgram [NL3D_VEGETABLE_NRDRPASS]
Misc data to setup renderState (computed at each render())
CVector	_AngleAxis
bool	_BkupFog
NLMISC::CMatrix	_ManagerMatrix
CVector	_ViewCenter
Wind animation
float	_CosTable [NL3D_VEGETABLE_VP_LUT_SIZE]
double	_Time
double	_WindAnimTime
float	_WindBendMin
NLMISC::CVector2f	_WindDeltaTable [NL3D_VEGETABLE_VP_LUT_SIZE]
CVector	_WindDirection
float	_WindFrequency
float	_WindPower
double	_WindPrecRenderTime
NLMISC::CVector2f	_WindTable [NL3D_VEGETABLE_VP_LUT_SIZE]
Friends
class	CVegetableBlendLayerModel

---

Member Typedef Documentation

typedef TShapeMap::iterator NL3D::CVegetableManager::ItShapeMap [private]

Definition at line 301 of file vegetable_manager.h. Referenced by getVegetableShape().

typedef std::map<std::string, CVegetableShape> NL3D::CVegetableManager::TShapeMap [private]

Definition at line 300 of file vegetable_manager.h.

---

Member Enumeration Documentation

enum NL3D::CVegetableManager::TVegetableWater

Micro vegetation position against Water. Above water is the default. Enumeration values: AboveWater  UnderWater  IntersectWater  VegetInfoLast  Definition at line 79 of file vegetable_manager.h. { AboveWater = 0, UnderWater, IntersectWater, VegetInfoLast };

---

Constructor & Destructor Documentation

NL3D::CVegetableManager::CVegetableManager (  uint  maxVertexVbHardUnlit, uint  maxVertexVbHardLighted, uint  nbBlendLayers = 20, float  blendLayerDistMax = 60.f )

Parameters: maxVertexVbHardUnlit  maximum VertexCount in VBHard for Unlit (or precomputed lighted) vegetables maxVertexVbHardLighted  maximum VertexCount in VBHard for Lighted vegetables nbBlendLayers  for ZSort/AlphaBlend rdrPass: number of layers of vegetables rendered independently. blendLayerDistMax  for ZSort/AlphaBlend rdrPass: distance of the farest layer. Definition at line 58 of file vegetable_manager.cpp. References _DirectionalLight, _GlobalAmbient, _GlobalDiffuse, _NumVegetableFaceRendered, _NumZSortBlendLayers, _ULCurrentIgInstance, _ULCurrentIgRdrPass, _ULNTotalVertices, _ULNVerticesToUpdate, _ULRootIg, _VBHardAllocator, _VBSoftAllocator, _VegetableMaterial, _WindAnimTime, _WindBendMin, _WindDirection, _WindFrequency, _WindPower, _WindPrecRenderTime, _ZSortModelLayers, _ZSortModelLayersUW, NL3D::CVegetableVBAllocator::init(), NL3D::CMaterial::initUnlit(), NL3D_VEGETABLE_CLIP_BLOCK_BLOCKSIZE, NL3D_VEGETABLE_INSTANCE_GROUP_BLOCKSIZE, NL3D_VEGETABLE_NRDRPASS, NL3D_VEGETABLE_SORT_BLOCK_BLOCKSIZE, NL3D_VEGETABLE_VP_LUT_SIZE, nlassert, NLMISC::CVector::normed(), NLMISC::Pi, NLMISC::CVector::set(), NLMISC::CRGBA::set(), NL3D::CMaterial::setAlphaTest(), NL3D::CMaterial::setBlendFunc(), and uint. : _ClipBlockMemory(NL3D_VEGETABLE_CLIP_BLOCK_BLOCKSIZE), _SortBlockMemory(NL3D_VEGETABLE_SORT_BLOCK_BLOCKSIZE), _InstanceGroupMemory(NL3D_VEGETABLE_INSTANCE_GROUP_BLOCKSIZE), _NumZSortBlendLayers(nbBlendLayers), _ZSortLayerDistMax(blendLayerDistMax), _ZSortScene(NULL) { uint i; // Init all the allocators nlassert((uint)(CVegetableVBAllocator::VBTypeCount) == 2); _VBHardAllocator[CVegetableVBAllocator::VBTypeLighted].init( CVegetableVBAllocator::VBTypeLighted, maxVertexVbHardLighted ); _VBHardAllocator[CVegetableVBAllocator::VBTypeUnlit].init( CVegetableVBAllocator::VBTypeUnlit, maxVertexVbHardUnlit ); // Init soft one, with no vbHard vertices. _VBSoftAllocator[CVegetableVBAllocator::VBTypeLighted].init( CVegetableVBAllocator::VBTypeLighted, 0 ); _VBSoftAllocator[CVegetableVBAllocator::VBTypeUnlit].init( CVegetableVBAllocator::VBTypeUnlit, 0 ); // NB Vertex programs are initilized during the first call to update driver. // setup the material. Unlit (doesn't matter, lighting in VP) Alpha Test. _VegetableMaterial.initUnlit(); _VegetableMaterial.setAlphaTest(true); _VegetableMaterial.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha); // default light. _DirectionalLight= (CVector(0,1, -1)).normed(); _GlobalAmbient.set(64, 64, 64, 255); _GlobalDiffuse.set(150, 150, 150, 255); // Wind. _WindDirection.set(1,0,0); _WindFrequency= 1; _WindPower= 1; _WindBendMin= 0; _Time= 0; _WindPrecRenderTime= 0; _WindAnimTime= 0; // Init CosTable. for(i=0; i<NL3D_VEGETABLE_VP_LUT_SIZE; i++) { _CosTable[i]= (float)cos( i*2*Pi / NL3D_VEGETABLE_VP_LUT_SIZE ); } // init to NULL _ZSortModelLayers. _NumZSortBlendLayers= max(1U, _NumZSortBlendLayers); _ZSortModelLayers.resize(_NumZSortBlendLayers, NULL); _ZSortModelLayersUW.resize(_NumZSortBlendLayers, NULL); // UL _ULFrequency= 0; _ULNVerticesToUpdate=0; _ULNTotalVertices= 0; _ULRootIg= NULL; _ULCurrentIgRdrPass= 0; _ULCurrentIgInstance= 0; _ULPrecTime= 0; _ULPrecTimeInit= false; _ULTime= 0; // Misc. _NumVegetableFaceRendered= 0; std::fill(_VertexProgram, _VertexProgram + NL3D_VEGETABLE_NRDRPASS, (CVertexProgram *) NULL); }

NL3D::CVegetableManager::~CVegetableManager (   )

Definition at line 129 of file vegetable_manager.cpp. References _NumZSortBlendLayers, _ZSortModelLayers, _ZSortModelLayersUW, _ZSortScene, NL3D::CScene::deleteModel(), NL3D_VEGETABLE_NRDRPASS, sint, and uint. { // delete All VP for(sint i=0; i <NL3D_VEGETABLE_NRDRPASS; i++) { delete _VertexProgram[i]; _VertexProgram[i]= NULL; } // delete ZSort models. if(_ZSortScene) { // remove models from scene. for(uint i= 0; i<_NumZSortBlendLayers; i++) { _ZSortScene->deleteModel(_ZSortModelLayers[i]); _ZSortModelLayers[i]= NULL; _ZSortScene->deleteModel(_ZSortModelLayersUW[i]); _ZSortModelLayersUW[i]= NULL; } _ZSortScene= NULL; } }

---

Member Function Documentation

void NL3D::CVegetableManager::addInstance (  CVegetableInstanceGroup *  ig, CVegetableShape *  shape, const NLMISC::CMatrix &  mat, const NLMISC::CRGBAF &  ambientColor, const NLMISC::CRGBAF &  diffuseColor, float  bendFactor, float  bendPhase, float  bendFreqFactor, float  blendDistMax, TVegetableWater  vegetWaterState, CVegetableUV8  dlmUV )

add an instance to an ig, enlarging the associated clipBlock bbox. If the shape is not lighted, then only diffuseColor is used, to setup color per vertex. Warning! Use OptFastFloor()! So call must be enclosed with a OptFastFloorBegin()/OptFastFloorEnd(). Also, buffer must be locked. ambientColor and diffuseColor should be in [0..1] (no clamp), else uint8 will wrap... nlassert() if no sufficient space reserved in reserveIgCompile(). Parameters: dlmUV  is the dynamic lightmap UV for this vegetable. See also: reserveIgAddInstances() reserveIgCompile() Definition at line 1036 of file vegetable_manager.cpp. References NL3D::CVegetableSortBlock::_Center, NL3D::CVegetableInstanceGroup::_ClipOwner, _DirectionalLight, NL3D::CVegetableSortBlock::_Dirty, _GlobalAmbient, _GlobalDiffuse, NL3D::CVegetableInstanceGroup::_HasZSortPassInstances, NL3D::CVegetableSortBlock::_InstanceGroupList, NL3D::CVegetableSortBlock::_Radius, NL3D::CVegetableInstanceGroup::_RdrPass, NL3D::CVegetableInstanceGroup::_SortOwner, NL3D::CVegetableInstanceGroup::_TriangleQuadrantOrderNumTriangles, NL3D::CVegetableInstanceGroup::_TriangleQuadrantOrders, _ULNTotalVertices, NL3D::CVegetableInstanceGroup::_ULNumVertices, _ULRootIg, NL3D::CVegetableSortBlock::_UnderWater, NLMISC::CRGBA::A, NL3D::CVegetableVBAllocator::allocateVertex(), NLMISC::CRGBAF::B, NLMISC::CRGBA::B, NL3D::CTessList< CVegetableInstanceGroup >::begin(), NL3D::CVegetableShape::BendCenterMode, NL3D::CVegetableShape::BestSidedPreComputeLighting, NL3D::CVegetableLightEx::Color, NL3D::computeVegetVertexLighting(), NL3D::computeVegetVertexLightingForceBestSided(), NLMISC::CObjectVector< uint32, false >::copy(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::DlmUV, NL3D::CVegetableVBAllocator::exceedMaxVertexInBufferHard(), NL3D::CVegetableClipBlock::extendBBoxOnly(), NL3D::CVegetableClipBlock::extendSphere(), NL3D::CVegetableVBAllocator::flushVertex(), NLMISC::CRGBAF::G, NLMISC::CRGBA::G, NL3D::CVertexBuffer::getNormalOff(), NL3D::CVertexBuffer::getNumVertices(), NLMISC::CMatrix::getPos(), getRdrPassInfoForShape(), NL3D::CVegetableVBAllocator::getSoftwareVertexBuffer(), NL3D::CVertexBuffer::getTexCoordOff(), NL3D::CVertexBuffer::getValueOffEx(), getVBAllocatorForRdrPassAndVBHardMode(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVegetableVBAllocator::getVertexPointer(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::HardMode, NL3D::CVegetableShape::InstanceVertices, NLMISC::CMatrix::invert(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::LightedInstances, NL3D::CVegetableInstanceGroup::linkBeforeUL(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::MatAmbient, NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::MatDiffuse, NLMISC::CRGBA::modulateFromColorRGBOnly(), NLMISC::CMatrix::mulVector(), NL3D::CTessNodeList::Next, NL3D_VEGETABLE_BLOCK_BLEND_TRANSITION_DIST, NL3D_VEGETABLE_FREQUENCY_FACTOR_PREC, NL3D_VEGETABLE_NUM_QUADRANT, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, NL3D_VEGETABLE_VPPOS_BENDINFO, NL3D_VEGETABLE_VPPOS_CENTER, NL3D_VEGETABLE_VPPOS_COLOR0, NL3D_VEGETABLE_VPPOS_COLOR1, NL3D_VEGETABLE_VPPOS_NORMAL, NL3D_VEGETABLE_VPPOS_TEX0, nlassert, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::NLightedInstances, NLMISC::CVector::norm(), NLMISC::CVector::normalize(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::NormalMat, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::NTriangles, NL3D::CVegetableLightEx::NumLights, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::NVertices, NLMISC::OptFastFloor(), NLMISC::CRGBAF::R, NLMISC::CRGBA::R, NLMISC::CMatrix::setRot(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::Shape, sint, sint16, NLMISC::CObjectVector< CVegetableLightedInstance >::size(), NLMISC::CObjectVector< uint32, false >::size(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::StartIdInRdrPass, swapIgRdrPassHardMode(), NLMISC::CMatrix::transpose(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::TriangleIndices, NL3D::CVegetableShape::TriangleIndices, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::TriangleLocalIndices, NL3D::CVegetableUV8::U, uint, uint8, NL3D::CVegetableClipBlock::updateSphere(), v, NL3D::CVegetableUV8::V, NL3D::CVegetableShape::VB, NL3D::CVegetableInstanceGroup::VegetableLightEx, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::Vertices, NLMISC::CVectorH::w, NLMISC::CVector::x, NLMISC::CVector::y, NLMISC::CVector::z, and NL3D::CVegetableSortBlock::ZSortHardMode. Referenced by NL3D::CVegetable::generateInstance(). { sint i; // Some setup. //-------------------- bool instanceLighted; bool instanceDoubleSided; bool instanceZSort; bool destLighted; bool precomputeLighting; // get correct rdrPass / info uint rdrPass; rdrPass= getRdrPassInfoForShape(shape, vegetWaterState, instanceLighted, instanceDoubleSided, instanceZSort, destLighted, precomputeLighting); // bestSided Precompute lighting or not?? bool bestSidedPrecomputeLighting= precomputeLighting && shape->BestSidedPreComputeLighting; // veget rdrPass CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= ig->_RdrPass[rdrPass]; // color. // setup using OptFastFloor. CRGBA ambientRGBA, diffuseRGBA; CRGBA primaryRGBA, secondaryRGBA; // diffuseColor diffuseRGBA.R= (uint8)NLMISC::OptFastFloor(diffuseColor.R*255); diffuseRGBA.G= (uint8)NLMISC::OptFastFloor(diffuseColor.G*255); diffuseRGBA.B= (uint8)NLMISC::OptFastFloor(diffuseColor.B*255); diffuseRGBA.A= 255; // ambientColor ambientRGBA.R= (uint8)NLMISC::OptFastFloor(ambientColor.R*255); ambientRGBA.G= (uint8)NLMISC::OptFastFloor(ambientColor.G*255); ambientRGBA.B= (uint8)NLMISC::OptFastFloor(ambientColor.B*255); ambientRGBA.A= 255; // For Lighted, modulate with global light. if(instanceLighted) { primaryRGBA.modulateFromColorRGBOnly(diffuseRGBA, _GlobalDiffuse); secondaryRGBA.modulateFromColorRGBOnly(ambientRGBA, _GlobalAmbient); } // if the instance is not lighted, then don't take care of lighting else { primaryRGBA.R= diffuseRGBA.R; primaryRGBA.G= diffuseRGBA.G; primaryRGBA.B= diffuseRGBA.B; // may not be useFull (2Sided lighting no more supported) secondaryRGBA= primaryRGBA; } // Copy Dynamic Lightmap UV in Alpha part (save memory for an extra cost of 1 VP instruction) primaryRGBA.A= dlmUV.U; secondaryRGBA.A= dlmUV.V; // get ref on the vegetLex. CVegetableLightEx &vegetLex= ig->VegetableLightEx; // Color of pointLights modulated by diffuse. CRGBA diffusePL[2]; if(vegetLex.NumLights>=1) { diffusePL[0].modulateFromColorRGBOnly(diffuseRGBA, vegetLex.Color[0]); if(vegetLex.NumLights>=2) { diffusePL[1].modulateFromColorRGBOnly(diffuseRGBA, vegetLex.Color[1]); } } // normalize bendFreqFactor bendFreqFactor*= NL3D_VEGETABLE_FREQUENCY_FACTOR_PREC; bendFreqFactor= (float)floor(bendFreqFactor + 0.5f); bendFreqFactor/= NL3D_VEGETABLE_FREQUENCY_FACTOR_PREC; // Get allocator, and manage VBhard overriding. //-------------------- CVegetableVBAllocator *allocator; // if still in Sfot mode, keep it. if(!vegetRdrPass.HardMode) { // get the soft allocator. allocator= &getVBAllocatorForRdrPassAndVBHardMode(rdrPass, 0); } else { // Get VB allocator Hard for this rdrPass allocator= &getVBAllocatorForRdrPassAndVBHardMode(rdrPass, 1); // Test if the instance don't add too many vertices for this VBHard if(allocator->exceedMaxVertexInBufferHard(shape->VB.getNumVertices())) { // if exceed, then must pass ALL the IG in software mode. vertices/faces are correclty updated. // special: if rdrPass is the ZSort one, if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) { nlassert(ig->_SortOwner->ZSortHardMode); // must do it on ALL igs of the sortBlock, for less VBuffer mode switching. CVegetableInstanceGroup *pIg= ig->_SortOwner->_InstanceGroupList.begin(); while(pIg) { // let's pass them in software mode. swapIgRdrPassHardMode(pIg, rdrPass); // next pIg= (CVegetableInstanceGroup*)pIg->Next; } // Then all The sortBlock is in SoftMode. ig->_SortOwner->ZSortHardMode= false; } else { // just do it on this Ig (can mix hardMode in a SortBlock for normal rdrPass) swapIgRdrPassHardMode(ig, rdrPass); } // now, we can use the software only Allocator to append our instance allocator= &getVBAllocatorForRdrPassAndVBHardMode(rdrPass, 0); } } // get correct dstVB const CVertexBuffer &dstVBInfo= allocator->getSoftwareVertexBuffer(); // Transform vertices to a vegetable instance, and enlarge clipBlock //-------------------- // compute matrix to multiply normals, ie (M-1)t CMatrix normalMat; // need just rotation scale matrix. normalMat.setRot(mat); normalMat.invert(); normalMat.transpose(); // compute Instance position CVector instancePos; mat.getPos(instancePos); // At least, the bbox of the clipBlock must include the center of the shape. ig->_ClipOwner->extendSphere(instancePos); // Vertex/triangle Info. uint numNewVertices= shape->VB.getNumVertices(); uint numNewTris= shape->TriangleIndices.size()/3; uint numNewIndices= shape->TriangleIndices.size(); // src info. uint srcNormalOff= (instanceLighted? shape->VB.getNormalOff() : 0); uint srcTex0Off= shape->VB.getTexCoordOff(0); uint srcTex1Off= shape->VB.getTexCoordOff(1); // dst info uint dstNormalOff= (destLighted? dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_NORMAL) : 0); uint dstColor0Off= dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_COLOR0); uint dstColor1Off= dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_COLOR1); uint dstTex0Off= dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_TEX0); uint dstBendOff= dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_BENDINFO); uint dstCenterOff= dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_CENTER); // Usefull For !destLighted only. CVector deltaPos; float deltaPosNorm=0.0; // UseFull for ZSORT rdrPass, the worldVertices. static vector<CVector> worldVertices; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) { worldVertices.resize(numNewVertices); } // For all vertices of shape, transform and store manager indices in temp shape. for(i=0; i<(sint)numNewVertices;i++) { // allocate a Vertex uint vid= allocator->allocateVertex(); // store in tmp shape. shape->InstanceVertices[i]= vid; // Fill this vertex. uint8 *srcPtr= (uint8*)shape->VB.getVertexCoordPointer(i); uint8 *dstPtr= (uint8*)allocator->getVertexPointer(vid); // Get bendWeight for this vertex. float vertexBendWeight= ((CUV*)(srcPtr + srcTex1Off))->U * bendFactor; // Pos. //------- // Separate Center and relative pos. CVector relPos= mat.mulVector(*(CVector*)srcPtr); // mulVector, because translation in v[center] // compute bendCenterPos CVector bendCenterPos; if(shape->BendCenterMode == CVegetableShapeBuild::BendCenterNull) bendCenterPos= CVector::Null; else { CVector v= *(CVector*)srcPtr; v.z= 0; bendCenterPos= mat.mulVector(v); // mulVector, because translation in v[center] } // copy deltaPos= relPos-bendCenterPos; *(CVector*)dstPtr= deltaPos; *(CVector*)(dstPtr + dstCenterOff)= instancePos + bendCenterPos; // if !destLighted, then VP is different if(!destLighted) { deltaPosNorm= deltaPos.norm(); // copy bendWeight in v.w CVectorH *vh= (CVectorH*)dstPtr; // Mul by deltaPosNorm, to draw an arc circle. vh->w= vertexBendWeight * deltaPosNorm; } // Enlarge the clipBlock of the IG. // Since small shape, enlarge with each vertices. simpler and maybe faster. // TODO_VEGET: bend and clipping ... ig->_ClipOwner->extendBBoxOnly(instancePos + relPos); // prepare for ZSort if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) { worldVertices[i]= instancePos + relPos; } // Color-ligthing. //------- if(!precomputeLighting) { // just copy the primary color (means diffuse part if lighted) *(CRGBA*)(dstPtr + dstColor0Off)= primaryRGBA; // normal and secondary color if(destLighted) { // normal *(CVector*)(dstPtr + dstNormalOff)= normalMat.mulVector( *(CVector*)(srcPtr + srcNormalOff) ); } // If destLighted, secondaryRGBA is the ambient // else secondaryRGBA is used only for Alpha (DLM uv.v). *(CRGBA*)(dstPtr + dstColor1Off)= secondaryRGBA; } else { nlassert(!destLighted); // compute normal. CVector rotNormal= normalMat.mulVector( *(CVector*)(srcPtr + srcNormalOff) ); // must normalize() because scale is possible. rotNormal.normalize(); // Do the compute. if(!bestSidedPrecomputeLighting) { computeVegetVertexLighting(rotNormal, _DirectionalLight, primaryRGBA, secondaryRGBA, vegetLex, diffusePL, (CRGBA*)(dstPtr + dstColor0Off) ); } else { computeVegetVertexLightingForceBestSided(rotNormal, _DirectionalLight, primaryRGBA, secondaryRGBA, vegetLex, diffusePL, (CRGBA*)(dstPtr + dstColor0Off) ); } // copy secondaryRGBA, used only for Alpha (DLM uv.v). *(CRGBA*)(dstPtr + dstColor1Off)= secondaryRGBA; } // Texture. //------- *(CUV*)(dstPtr + dstTex0Off)= *(CUV*)(srcPtr + srcTex0Off); // Bend. //------- CVector *dstBendPtr= (CVector*)(dstPtr + dstBendOff); // setup bend Phase. dstBendPtr->y= bendPhase; // setup bend Weight. // if !destLighted, then VP is different, vertexBendWeight is stored in v[0].w if(destLighted) dstBendPtr->x= vertexBendWeight; else // the VP need the norm of relPos in v[9].x dstBendPtr->x= deltaPosNorm; // setup bendFreqFactor dstBendPtr->z= bendFreqFactor; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) { // get ptr on v[9].w NB: in Unlit mode, it has 4 components. CVectorH *dstBendPtr= (CVectorH*)(dstPtr + dstBendOff); // setup the constant of linear formula: // Alpha= -1/blendTransDist * dist + blendDistMax/blendTransDist dstBendPtr->w= blendDistMax/NL3D_VEGETABLE_BLOCK_BLEND_TRANSITION_DIST; } // fill the vertex in AGP. //------- allocator->flushVertex(vid); } // must recompute the sphere according to the bbox. ig->_ClipOwner->updateSphere(); // If ZSort, compute Triangle Centers and Orders for quadrant //-------------------- if(rdrPass==NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) { // inform the SB that it must be updated. ig->_SortOwner->_Dirty= true; // For deletion, inform the ig that it has instances which impact the SB. ig->_HasZSortPassInstances= true; // change UnderWater falg of the SB if(vegetWaterState == AboveWater) ig->_SortOwner->_UnderWater= false; else if(vegetWaterState == UnderWater) ig->_SortOwner->_UnderWater= true; // static to avoid reallocation static vector<CVector> triangleCenters; triangleCenters.resize(numNewTris); // compute triangle centers for(uint i=0; i<numNewTris; i++) { // get index in shape. uint v0= shape->TriangleIndices[i*3+0]; uint v1= shape->TriangleIndices[i*3+1]; uint v2= shape->TriangleIndices[i*3+2]; // get world coord. const CVector &vert0= worldVertices[v0]; const CVector &vert1= worldVertices[v1]; const CVector &vert2= worldVertices[v2]; // compute center triangleCenters[i]= (vert0 + vert1 + vert2) / 3; // relative to center of the sortBlock (for sint16 compression) triangleCenters[i]-= ig->_SortOwner->_Center; } // resize the array. Actually only modify the number of triangles really setuped. uint offTri= ig->_TriangleQuadrantOrderNumTriangles; ig->_TriangleQuadrantOrderNumTriangles+= numNewTris; // verify user has correclty used reserveIg system. nlassert(ig->_TriangleQuadrantOrderNumTriangles * NL3D_VEGETABLE_NUM_QUADRANT <= ig->_TriangleQuadrantOrderArray.size()); // compute distance for each quadrant. Since we are not sure of the sortBlockSize, mul with a (big: 16) security. // NB: for landscape practical usage, this left us with more than 1mm precision. float distFactor=32768/(16*ig->_SortOwner->_Radius); for(uint quadId=0; quadId<NL3D_VEGETABLE_NUM_QUADRANT; quadId++) { const CVector &quadDir= CVegetableQuadrant::Dirs[quadId]; // For all tris. for(uint i=0; i<numNewTris; i++) { // compute the distance with orientation of the quadrant. (DotProduct) float dist= triangleCenters[i] * quadDir; // compress to sint16. ig->_TriangleQuadrantOrders[quadId][offTri + i]= (sint16)NLMISC::OptFastFloor(dist*distFactor); } } } // Append list of indices and list of triangles to the IG //-------------------- // TODO_VEGET_OPTIM: system reallocation of array is very bad... // compute dest start idx. uint offVertex= vegetRdrPass.NVertices; uint offTri= vegetRdrPass.NTriangles; uint offTriIdx= offTri*3; // verify user has correclty used reserveIg system. nlassert(offVertex + numNewVertices <= vegetRdrPass.Vertices.size()); nlassert(offTriIdx + numNewIndices <= vegetRdrPass.TriangleIndices.size()); nlassert(offTriIdx + numNewIndices <= vegetRdrPass.TriangleLocalIndices.size()); // insert list of vertices to delete in ig vertices. vegetRdrPass.Vertices.copy(offVertex, offVertex+numNewVertices, &shape->InstanceVertices[0]); // insert array of triangles in ig. // for all indices, fill IG for(i=0; i<(sint)numNewIndices; i++) { // get the index of the vertex in the shape uint vid= shape->TriangleIndices[i]; // re-direction, using InstanceVertices; vegetRdrPass.TriangleIndices[offTriIdx + i]= shape->InstanceVertices[vid]; // local re-direction: adding vertexOffset. vegetRdrPass.TriangleLocalIndices[offTriIdx + i]= offVertex + vid; } // new triangle and vertex size. vegetRdrPass.NTriangles+= numNewTris; vegetRdrPass.NVertices+= numNewVertices; // if lighted, must add a lightedInstance for lighting update. //-------------------- if(instanceLighted) { // first, update Ig. ig->_ULNumVertices+= numNewVertices; // and update the vegetable manager. _ULNTotalVertices+= numNewVertices; // link at the end of the circular list: link before the current root. if(_ULRootIg==NULL) _ULRootIg= ig; else ig->linkBeforeUL(_ULRootIg); // check good use of reserveIg. nlassert(vegetRdrPass.NLightedInstances < vegetRdrPass.LightedInstances.size()); // Fill instance info CVegetableInstanceGroup::CVegetableLightedInstance &vli= vegetRdrPass.LightedInstances[vegetRdrPass.NLightedInstances]; vli.Shape= shape; vli.NormalMat= normalMat; // copy colors unmodulated by global light. vli.MatAmbient= ambientRGBA; vli.MatDiffuse= diffuseRGBA; // store dynamic lightmap UV vli.DlmUV= dlmUV; // where vertices of this instances are wrote in the VegetRdrPass vli.StartIdInRdrPass= offVertex; // Inc size setuped. vegetRdrPass.NLightedInstances++; } }

CVegetableClipBlock * NL3D::CVegetableManager::createClipBlock (   )

Create a clipBlock where SortBlock will be created. Definition at line 607 of file vegetable_manager.cpp. References _ClipBlockMemory, _EmptyClipBlockList, NLMISC::CBlockMemory< CVegetableClipBlock >::allocate(), and NL3D::CTessList< CVegetableClipBlock >::append(). Referenced by NL3D::CPatch::addRefTessBlocks(). { // create a clipblock CVegetableClipBlock *ret; ret= _ClipBlockMemory.allocate(); // append to list. _EmptyClipBlockList.append(ret); return ret; }

CVegetableInstanceGroup * NL3D::CVegetableManager::createIg (  CVegetableSortBlock *  sortBlock  )

create an instance group in a sortBlock, where instances will be created. Instances will be frustum-clipped by the clipBlock, and sorted (for the ZSort rdrPass only) by sortBlock. Definition at line 672 of file vegetable_manager.cpp. References _ClipBlockList, NL3D::CVegetableInstanceGroup::_ClipOwner, _EmptyClipBlockList, NL3D::CVegetableSortBlock::_InstanceGroupList, _InstanceGroupMemory, NL3D::CVegetableClipBlock::_NumIgs, NL3D::CVegetableSortBlock::_Owner, NL3D::CVegetableInstanceGroup::_RdrPass, NL3D::CVegetableInstanceGroup::_SortOwner, NLMISC::CBlockMemory< CVegetableInstanceGroup >::allocate(), NL3D::CTessList< CVegetableInstanceGroup >::append(), NL3D::CTessList< CVegetableClipBlock >::append(), NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, nlassert, NL3D::CTessList< CVegetableClipBlock >::remove(), and NL3D::CVegetableSortBlock::ZSortHardMode. Referenced by NL3D::CLandscapeVegetableBlock::createVegetableIGForDistType(). { nlassert(sortBlock); CVegetableClipBlock *clipBlock= sortBlock->_Owner; // create an IG CVegetableInstanceGroup *ret; ret= _InstanceGroupMemory.allocate(); ret->_SortOwner= sortBlock; ret->_ClipOwner= clipBlock; // if the clipBlock is empty, change list, because won't be no more. if(clipBlock->_NumIgs==0) { // remove from empty list _EmptyClipBlockList.remove(clipBlock); // and append to not empty one. _ClipBlockList.append(clipBlock); } // inc the number of igs appended to the clipBlock. clipBlock->_NumIgs++; // link ig to sortBlock. sortBlock->_InstanceGroupList.append(ret); // Special Init: The ZSort rdrPass must start with the same HardMode than SortBlock. ret->_RdrPass[NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT].HardMode= sortBlock->ZSortHardMode; return ret; }

CVegetableSortBlock * NL3D::CVegetableManager::createSortBlock (  CVegetableClipBlock *  clipBlock, const CVector &  center, float  radius )

Create a SortBlock in a clipBlock where instance group (ig) will be created. All AlphaBlend instances created in a SortBlock should have the same vegetWaterState: AboveWater or UnderWater. Each time an instance is added to the sortBlock it changes the _UnderWater state of the sortBlock. Parameters: center  you must give an approximate center for the sortBlock (for sorting) radius  you must give an approximate radius for the sortBlock (for the system to know when you are IN the sortBlock, and then to sort in a better way) Definition at line 637 of file vegetable_manager.cpp. References NL3D::CVegetableSortBlock::_Center, NL3D::CVegetableSortBlock::_Owner, NL3D::CVegetableSortBlock::_Radius, NL3D::CVegetableClipBlock::_SortBlockList, _SortBlockMemory, NLMISC::CBlockMemory< CVegetableSortBlock >::allocate(), NL3D::CTessList< CVegetableSortBlock >::append(), and nlassert. Referenced by NL3D::CLandscapeVegetableBlock::init(). { nlassert(clipBlock); // create a clipblock CVegetableSortBlock *ret; ret= _SortBlockMemory.allocate(); ret->_Owner= clipBlock; ret->_Center= center; ret->_Radius= radius; // append to list. clipBlock->_SortBlockList.append(ret); return ret; }

void NL3D::CVegetableManager::createVegetableBlendLayersModels (  CScene *  scene  )

Before any render(), you must call this method (else nlassert). It creates the necessary models in the scene, to manage AlphaBlending correctly. Those models are deleted in the object dtor. Definition at line 156 of file vegetable_manager.cpp. References _NumZSortBlendLayers, _ZSortModelLayers, _ZSortModelLayersUW, _ZSortScene, nlassert, uint, and NL3D::VegetableBlendLayerModelId. Referenced by NL3D::CLandscape::createVegetableBlendLayersModels(). { // setup scene nlassert(scene); _ZSortScene= scene; // create the layers models. for(uint i=0;i<_NumZSortBlendLayers; i++) { // assert not already done. nlassert(_ZSortModelLayers[i]==NULL); nlassert(_ZSortModelLayersUW[i]==NULL); _ZSortModelLayers[i]= (CVegetableBlendLayerModel*)scene->createModel(VegetableBlendLayerModelId); _ZSortModelLayersUW[i]= (CVegetableBlendLayerModel*)scene->createModel(VegetableBlendLayerModelId); // init owner. _ZSortModelLayers[i]->VegetableManager= this; _ZSortModelLayersUW[i]->VegetableManager= this; // Set UnderWater layer for _ZSortModelLayersUW _ZSortModelLayersUW[i]->setOrderingLayer(2); } }

void NL3D::CVegetableManager::deleteClipBlock (  CVegetableClipBlock *  clipBlock  )

delete such a clipBlock. all sortBlocks and so all ig must be deleted before. Definition at line 620 of file vegetable_manager.cpp. References _ClipBlockMemory, _EmptyClipBlockList, NL3D::CVegetableClipBlock::_SortBlockList, NLMISC::CBlockMemory< CVegetableClipBlock >::free(), nlassert, NL3D::CTessList< CVegetableClipBlock >::remove(), and NL3D::CTessList< CVegetableSortBlock >::size(). Referenced by NL3D::CPatch::clearTessBlocks(). { if(!clipBlock) return; // verify no more sortBlocks in this clipblock nlassert(clipBlock->_SortBlockList.size() == 0); // unlink from _EmptyClipBlockList, because _InstanceGroupList.size() == 0 ... _EmptyClipBlockList.remove(clipBlock); // delete _ClipBlockMemory.free(clipBlock); }

void NL3D::CVegetableManager::deleteIg (  CVegetableInstanceGroup *  ig  )

delete such an ig. After doing this, you must call igSortBlockOwner->updateSortBlock() If the sortBlock has many Igs, you can do it after deleting all your igs. Definition at line 706 of file vegetable_manager.cpp. References _ClipBlockList, NL3D::CVegetableInstanceGroup::_ClipOwner, NL3D::CVegetableSortBlock::_Dirty, _EmptyClipBlockList, NL3D::CVegetableInstanceGroup::_HasZSortPassInstances, NL3D::CVegetableSortBlock::_InstanceGroupList, _InstanceGroupMemory, NL3D::CVegetableClipBlock::_NumIgs, NL3D::CVegetableInstanceGroup::_RdrPass, NL3D::CVegetableInstanceGroup::_SortOwner, _ULCurrentIgInstance, _ULCurrentIgRdrPass, NL3D::CVegetableInstanceGroup::_ULNext, _ULNTotalVertices, NL3D::CVegetableInstanceGroup::_ULNumVertices, _ULRootIg, NL3D::CTessList< CVegetableClipBlock >::append(), NLMISC::CObjectVector< uint32, false >::clear(), NL3D::CVegetableVBAllocator::deleteVertex(), NLMISC::CBlockMemory< CVegetableInstanceGroup >::free(), getVBAllocatorForRdrPassAndVBHardMode(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::HardMode, NL3D_VEGETABLE_NRDRPASS, nlassert, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::NVertices, NL3D::CTessList< CVegetableClipBlock >::remove(), NL3D::CTessList< CVegetableInstanceGroup >::remove(), sint, NLMISC::CObjectVector< uint32, false >::size(), uint, NL3D::CVegetableInstanceGroup::unlinkUL(), and NL3D::CVegetableInstanceGroup::CVegetableRdrPass::Vertices. Referenced by NL3D::CLandscapeVegetableBlock::createVegetableIGForDistType(), NL3D::CLandscapeVegetableBlock::release(), and NL3D::CLandscapeVegetableBlock::update(). { if(!ig) return; // update lighting mgt: no more vertices. // ----------- // If I delete the ig which is the current root if(_ULRootIg == ig) { // switch to next _ULRootIg= ig->_ULNext; // if still the same, it means that the circular list is now empty if(_ULRootIg == ig) _ULRootIg= NULL; // Reset UL instance info. _ULCurrentIgRdrPass= 0; _ULCurrentIgInstance= 0; } // remove UL vertex count of the deleted ig _ULNTotalVertices-= ig->_ULNumVertices; // unlink the ig for lighting update. ig->unlinkUL(); // For all render pass of this instance, delete his vertices // ----------- for(sint rdrPass=0; rdrPass < NL3D_VEGETABLE_NRDRPASS; rdrPass++) { // rdrPass CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= ig->_RdrPass[rdrPass]; // which allocator? CVegetableVBAllocator &vbAllocator= getVBAllocatorForRdrPassAndVBHardMode(rdrPass, vegetRdrPass.HardMode); // For all vertices of this rdrPass, delete it sint numVertices; numVertices= vegetRdrPass.Vertices.size(); // all vertices must have been setuped. nlassert((uint)numVertices == vegetRdrPass.NVertices); for(sint i=0; i<numVertices;i++) { vbAllocator.deleteVertex(vegetRdrPass.Vertices[i]); } vegetRdrPass.Vertices.clear(); } CVegetableClipBlock *clipBlock= ig->_ClipOwner; CVegetableSortBlock *sortBlock= ig->_SortOwner; // If I have got some faces in ZSort rdrPass if(ig->_HasZSortPassInstances) // after my deletion, the sortBlock must be updated. sortBlock->_Dirty= true; // unlink from sortBlock, and delete. sortBlock->_InstanceGroupList.remove(ig); _InstanceGroupMemory.free(ig); // decRef the clipBlock clipBlock->_NumIgs--; // if the clipBlock is now empty, change list if(clipBlock->_NumIgs==0) { // remove from normal list _ClipBlockList.remove(clipBlock); // and append to empty list. _EmptyClipBlockList.append(clipBlock); } }

void NL3D::CVegetableManager::deleteSortBlock (  CVegetableSortBlock *  sortBlock  )

delete such a SortBlock. all ig must be deleted before. Definition at line 655 of file vegetable_manager.cpp. References NL3D::CVegetableSortBlock::_InstanceGroupList, NL3D::CVegetableSortBlock::_Owner, NL3D::CVegetableClipBlock::_SortBlockList, _SortBlockMemory, NLMISC::CBlockMemory< CVegetableSortBlock >::free(), nlassert, NL3D::CTessList< CVegetableSortBlock >::remove(), and NL3D::CTessList< CVegetableInstanceGroup >::size(). Referenced by NL3D::CLandscapeVegetableBlock::release(). { if(!sortBlock) return; // verify no more IGs in this sortblock nlassert(sortBlock->_InstanceGroupList.size() == 0); // unlink from clipBlock sortBlock->_Owner->_SortBlockList.remove(sortBlock); // delete _SortBlockMemory.free(sortBlock); }

bool NL3D::CVegetableManager::doubleSidedRdrPass (  uint  rdrPass  )  [static, private]

Definition at line 1560 of file vegetable_manager.cpp. References NL3D_VEGETABLE_NRDRPASS, NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, nlassert, and uint. Referenced by render(), and setupRenderStateForBlendLayerModel(). { nlassert(rdrPass<NL3D_VEGETABLE_NRDRPASS); return (rdrPass == NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED) || (rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED) || (rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT); }

void NL3D::CVegetableManager::doUpdateLighting (   )  [private]

update lighting according to _ULNVerticesToUpdate Definition at line 2262 of file vegetable_manager.cpp. References NL3D::CVegetableInstanceGroup::_ULNext, _ULNVerticesToUpdate, _ULRootIg, and updateLightingIGPart(). Referenced by updateLighting(), and updateLightingAll(). { // while there is still some vertices to update. while(_ULNVerticesToUpdate > 0 && _ULRootIg) { // update the current ig. if all updated, skip to next one. if(updateLightingIGPart()) { // next _ULRootIg= _ULRootIg->_ULNext; } } // Now, _ULNVerticesToUpdate should be <=0. (most of the time < 0) }

void NL3D::CVegetableManager::exitRenderStateForBlendLayerModel (  IDriver *  driver  )  [private]

Definition at line 2180 of file vegetable_manager.cpp. References _BkupFog, NL3D::IDriver::activeVertexProgram(), and NL3D::IDriver::enableFog(). Referenced by NL3D::CVegetableBlendLayerModel::render(). { // disable VertexProgram. driver->activeVertexProgram(NULL); // restore Fog. driver->enableFog(_BkupFog); }

uint NL3D::CVegetableManager::getNumVegetableFaceRendered (   )  const

get the number of faces rendered by the vegetable manager Definition at line 2173 of file vegetable_manager.cpp. References _NumVegetableFaceRendered, and uint. Referenced by NL3D::CLandscape::getNumVegetableFaceRendered(). { return _NumVegetableFaceRendered; }

uint NL3D::CVegetableManager::getRdrPassInfoForShape (  CVegetableShape *  shape, TVegetableWater  vegetWaterState, bool &  instanceLighted, bool &  instanceDoubleSided, bool &  instanceZSort, bool &  destLighted, bool &  precomputeLighting )  [private]

get the rdrPass and other info for a given shape. Definition at line 817 of file vegetable_manager.cpp. References NL3D::CVegetableShape::AlphaBlend, NL3D::CVegetableShape::DoubleSided, NL3D::CVegetableShape::Lighted, NL3D_VEGETABLE_RDRPASS_LIGHTED, NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, NL3D::CVegetableShape::PreComputeLighting, and uint. Referenced by addInstance(), and reserveIgAddInstances(). { instanceLighted= shape->Lighted; instanceDoubleSided= shape->DoubleSided; // Disable ZSorting when we intersect water. instanceZSort= shape->AlphaBlend && vegetWaterState!=IntersectWater; destLighted= instanceLighted && !shape->PreComputeLighting; precomputeLighting= instanceLighted && shape->PreComputeLighting; // get correct rdrPass uint rdrPass; // get according to lighted / doubleSided state if(destLighted) { if(instanceDoubleSided) rdrPass= NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED; else rdrPass= NL3D_VEGETABLE_RDRPASS_LIGHTED; } else { if(instanceDoubleSided) { if(instanceZSort) rdrPass= NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT; else rdrPass= NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED; } else rdrPass= NL3D_VEGETABLE_RDRPASS_UNLIT; } return rdrPass; }

CVegetableVBAllocator & NL3D::CVegetableManager::getVBAllocatorForRdrPassAndVBHardMode (  uint  rdrPass, uint  vbHardMode )  [private]

Get the good allocator for the appropriate rdr pass. Definition at line 182 of file vegetable_manager.cpp. References _VBHardAllocator, _VBSoftAllocator, NL3D_VEGETABLE_RDRPASS_LIGHTED, NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, nlstop, and uint. Referenced by addInstance(), deleteIg(), render(), NL3D::CVegetableBlendLayerModel::render(), swapIgRdrPassHardMode(), and updateInstanceLighting(). { // If software VB if(vbHardMode==0) { if(rdrPass == NL3D_VEGETABLE_RDRPASS_LIGHTED) return _VBSoftAllocator[CVegetableVBAllocator::VBTypeLighted]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED) return _VBSoftAllocator[CVegetableVBAllocator::VBTypeLighted]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT) return _VBSoftAllocator[CVegetableVBAllocator::VBTypeUnlit]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED) return _VBSoftAllocator[CVegetableVBAllocator::VBTypeUnlit]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) return _VBSoftAllocator[CVegetableVBAllocator::VBTypeUnlit]; } // If hard VB else { if(rdrPass == NL3D_VEGETABLE_RDRPASS_LIGHTED) return _VBHardAllocator[CVegetableVBAllocator::VBTypeLighted]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED) return _VBHardAllocator[CVegetableVBAllocator::VBTypeLighted]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT) return _VBHardAllocator[CVegetableVBAllocator::VBTypeUnlit]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED) return _VBHardAllocator[CVegetableVBAllocator::VBTypeUnlit]; if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) return _VBHardAllocator[CVegetableVBAllocator::VBTypeUnlit]; } // abnormal case nlstop; // To avoid warning; return _VBSoftAllocator[0]; }

CVegetableShape * NL3D::CVegetableManager::getVegetableShape (  const std::string &  shape  )

Load a shape if necessary, and return a shapeId for this shape. Definition at line 781 of file vegetable_manager.cpp. References ItShapeMap, NL3D::CVegetableShape::loadShape(), and nlwarning. Referenced by NL3D::CVegetable::registerToManager(). { ItShapeMap it= _ShapeMap.find(shape); // if found if(it != _ShapeMap.end()) return &it->second; // else insert { // insert. CVegetableShape *ret; it= ( _ShapeMap.insert(make_pair(shape, CVegetableShape()) ) ).first; ret= &it->second; // fill. try { ret->loadShape(shape); } catch (Exception &e) { // Warning nlwarning ("CVegetableManager::getVegetableShape error while loading shape file '%s' : '%s'", shape.c_str (), e.what ()); // Remove from map _ShapeMap.erase (shape); // Return NULL ret = NULL; } return ret; } }

void NL3D::CVegetableManager::initVertexProgram (  uint  vpType  )  [private]

init the ith vertexProgram. Definition at line 562 of file vegetable_manager.cpp. References _LastDriver, NL3D::NL3D_BendProgram, NL3D::NL3D_CommonEndVegetableProgram, NL3D::NL3D_FastBendProgram, NL3D::NL3D_LightedStartVegetableProgram, NL3D::NL3D_UnlitAlphaBlendVegetableProgram, NL3D::NL3D_UnlitStartVegetableProgram, NL3D_VEGETABLE_RDRPASS_LIGHTED, NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, nlassert, and uint. Referenced by updateDriver(). { nlassert(_LastDriver); // update driver should have been called at least once ! // Init the Vertex Program. string vpgram; // start always with Bend. if( vpType==NL3D_VEGETABLE_RDRPASS_LIGHTED || vpType==NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED ) vpgram= NL3D_BendProgram; else vpgram= NL3D_FastBendProgram; // combine the VP according to Type switch(vpType) { case NL3D_VEGETABLE_RDRPASS_LIGHTED: case NL3D_VEGETABLE_RDRPASS_LIGHTED_2SIDED: vpgram+= string(NL3D_LightedStartVegetableProgram); break; case NL3D_VEGETABLE_RDRPASS_UNLIT: case NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED: vpgram+= string(NL3D_UnlitStartVegetableProgram); break; case NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT: vpgram+= string(NL3D_UnlitStartVegetableProgram); vpgram+= string(NL3D_UnlitAlphaBlendVegetableProgram); break; } // common end of VP vpgram+= string(NL3D_CommonEndVegetableProgram); // create VP. _VertexProgram[vpType]= new CVertexProgram(vpgram.c_str()); }

void NL3D::CVegetableManager::loadTexture (  ITexture *  itex  )

setup a global texture used for all vegetables (smartPtr-ized). Definition at line 1604 of file vegetable_manager.cpp. References _VegetableMaterial, and NL3D::CMaterial::setTexture(). { // setup a ITexture (smartPtr-ized). // Store in stage1, for dynamicLightmaping _VegetableMaterial.setTexture(1, itex); }

void NL3D::CVegetableManager::loadTexture (  const std::string &  texName  )

load a global texture used for all vegetables (lookup into CPath). Definition at line 1592 of file vegetable_manager.cpp. References NL3D::ITexture::setFilterMode(), NL3D::ITexture::setWrapS(), and NL3D::ITexture::setWrapT(). Referenced by NL3D::CLandscape::loadVegetableTexture(). { // setup a CTextureFile (smartPtr-ized). ITexture *tex= new CTextureFile(texName); loadTexture(tex); // setup good params. tex->setFilterMode(ITexture::Linear, ITexture::LinearMipMapLinear); tex->setWrapS(ITexture::Clamp); tex->setWrapT(ITexture::Clamp); }

void NL3D::CVegetableManager::lockBuffers (   )

lock any AGP vertex buffers. Do it wisely (just one time before refine as example). You MUST enclose calls to addInstance() (and so CVegetable::generateInstance()) with lockBuffers() / unlockBuffers(). Definition at line 1622 of file vegetable_manager.cpp. References _VBHardAllocator, _VBSoftAllocator, NL3D::CVegetableVBAllocator::lockBuffer(), and uint. Referenced by NL3D::CLandscape::lockBuffers(). { // lock all buffers for(uint i=0; i <CVegetableVBAllocator::VBTypeCount; i++) { _VBHardAllocator[i].lockBuffer(); _VBSoftAllocator[i].lockBuffer(); } }

void NL3D::CVegetableManager::render (  const CVector &  viewCenter, const CVector &  frontVector, const std::vector< CPlane > &  pyramid, ITexture *  textureDLM, IDriver *  driver )

render the manager into a driver, with current viewMatrix/frustum/fog setuped Buffers should be unlocked. Parameters: textureDLM  is the dynamic lightmap to use. can be NULL if don't want DLM Definition at line 1713 of file vegetable_manager.cpp. References _AngleAxis, NL3D::CVegetableSortBlock::_Center, _ClipBlockList, NL3D::CVegetableSortBlock::_InstanceGroupList, _ManagerMatrix, NL3D::CVegetableSortBlock::_NTriangles, _NumVegetableFaceRendered, _NumZSortBlendLayers, NL3D::CVegetableSortBlock::_QuadrantId, NL3D::CVegetableSortBlock::_Radius, NL3D::CVegetableInstanceGroup::_RdrPass, NL3D::CVegetableClipBlock::_RenderNext, NL3D::CVegetableClipBlock::_SortBlockList, NL3D::CVegetableSortBlock::_SortKey, NL3D::CVegetableSortBlock::_UnderWater, _VegetableMaterial, _ViewCenter, _WindAnimTime, _WindBendMin, _WindDeltaTable, _WindDirection, _WindFrequency, _WindPower, _WindPrecRenderTime, _WindTable, _ZSortLayerDistMax, _ZSortModelLayers, _ZSortModelLayersUW, NL3D::CVegetableVBAllocator::activate(), NL3D::IDriver::activeVertexProgram(), NL3D::CTessList< CVegetableInstanceGroup >::begin(), NL3D::CTessList< CVegetableSortBlock >::begin(), NL3D::CTessList< CVegetableClipBlock >::begin(), NLMISC::clamp(), NL3D::CVegetableClipBlock::clip(), doubleSidedRdrPass(), NL3D::IDriver::enableFog(), NL3D::IDriver::fogEnabled(), NL3D::CVegetableVBAllocator::getNumUserVerticesAllocated(), getVBAllocatorForRdrPassAndVBHardMode(), H_AUTO, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::HardMode, NLMISC::CMatrix::identity(), NL3D::CTessNodeList::Next, NL3D_VEGETABLE_FREQUENCY_FACTOR_PREC, NL3D_VEGETABLE_NRDRPASS, NL3D_VEGETABLE_NUM_QUADRANT, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, NL3D_VEGETABLE_VP_LUT_SIZE, nlassert, nlverify, NLMISC::CVector::norm(), NLMISC::CVector::normed(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::NTriangles, NL3D::CPrimitiveProfile::NTriangles, NLMISC::OptFastFloor(), NL3D::IDriver::profileRenderedPrimitives(), NL3D::IDriver::renderSimpleTriangles(), NLMISC::CVector::set(), NL3D::CMaterial::setAlphaTestThreshold(), NL3D::CMaterial::setBlend(), NL3D::CMaterial::setDoubleSided(), NLMISC::CMatrix::setPos(), NL3D::CMaterial::setTexture(), NL3D::IDriver::setupMaterial(), NL3D::IDriver::setupModelMatrix(), setupVertexProgramConstants(), NL3D::CMaterial::setZWrite(), sint, NL3D::CMaterial::texEnvArg0Alpha(), NL3D::CMaterial::texEnvArg0RGB(), NL3D::CMaterial::texEnvArg1Alpha(), NL3D::CMaterial::texEnvArg1RGB(), NL3D::CMaterial::texEnvOpAlpha(), NL3D::CMaterial::texEnvOpRGB(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::TriangleIndices, uint, updateDriver(), NLMISC::CVector::x, NLMISC::CVector::y, and z. Referenced by NL3D::CLandscape::render(). { H_AUTO( NL3D_Vegetable_Render ); CVegetableClipBlock *rootToRender= NULL; // get normalized front vector. CVector frontVectorNormed= frontVector.normed(); // For Speed debug only. /*extern bool YOYO_ATTest; if(YOYO_ATTest) return; */ // Clip. //-------------------- // For all current not empty clipBlocks, clip against pyramid, and insert visibles in list. CVegetableClipBlock *ptrClipBlock= _ClipBlockList.begin(); while(ptrClipBlock) { // if the clipBlock is visible and not empty if(ptrClipBlock->clip(pyramid)) { // insert into visible list. ptrClipBlock->_RenderNext= rootToRender; rootToRender= ptrClipBlock; } // next ptrClipBlock= (CVegetableClipBlock*)ptrClipBlock->Next; } // If no clip block visible, just skip!! if(rootToRender==NULL) return; // Prepare Render //-------------------- // profile. CPrimitiveProfile ppIn, ppOut; driver->profileRenderedPrimitives(ppIn, ppOut); uint precNTriRdr= ppOut.NTriangles; // Disable Fog. bool bkupFog; bkupFog= driver->fogEnabled(); driver->enableFog(false); // Used by setupVertexProgramConstants(). The center of camera. // Used for AlphaBlending, and for ZBuffer precision problems. _ViewCenter= viewCenter; // The manager is identity in essence. But for ZBuffer improvements, must set it as close // to the camera. In the VertexProgram, _ViewCenter is substracted from bent vertex pos. So take it as position. _ManagerMatrix.identity(); _ManagerMatrix.setPos(_ViewCenter); // set model matrix to the manager matrix. driver->setupModelMatrix(_ManagerMatrix); // set the driver for all allocators updateDriver(driver); // Compute Bend Anim. // AnimFrequency factor. // Doing it incrementaly allow change of of frequency each frame with good results. _WindAnimTime+= (_Time - _WindPrecRenderTime)*_WindFrequency; _WindAnimTime= fmod(_WindAnimTime, (float)NL3D_VEGETABLE_FREQUENCY_FACTOR_PREC); // NB: Leave timeBend (_WindAnimTime) as a time (ie [0..1]), because VP do a "EXP time". // For incremental computing. _WindPrecRenderTime= _Time; // compute the angleAxis corresponding to direction // perform a 90deg rotation to get correct angleAxis _AngleAxis.set(-_WindDirection.y,_WindDirection.x,0); // Fill LUT WindTable. uint i; for(i=0; i<NL3D_VEGETABLE_VP_LUT_SIZE; i++) { /* NB: this formula works quite well, because vertex BendFactor is expressed in Radian/2. And since animFactor==(_CosTable[i] + 1) E [0..2], we have here an arc-cirle computing: dmove= Radius * AngleRadian/2 * animFactor. So at max of animFactor (ie 2), we have: dmove= Radius * AngleRadian, which is by definition an arc-cirle computing... And so this approximate the Bend-quaternion Vertex Program. */ float windForce= (_CosTable[(i+32)%64] + 1); // Modify with _WindPower / _WindBendMin. windForce= _WindBendMin*2 + windForce * (1-_WindBendMin); windForce*= _WindPower; // Compute direction of the wind, and multiply by windForce. _WindTable[i]= CVector2f(_WindDirection.x, _WindDirection.y) * windForce; } // compute delta for(i=0; i<NL3D_VEGETABLE_VP_LUT_SIZE; i++) { CVector2f cur= _WindTable[i]; CVector2f delta= _WindTable[ (i+1)%NL3D_VEGETABLE_VP_LUT_SIZE ] - cur; _WindDeltaTable[i]= delta; } // setup VP constants. setupVertexProgramConstants(driver); // Setup TexEnvs for Dynamic lightmapping //-------------------- // if the dynamic lightmap is provided if(textureDLM) { // stage0 RGB is Diffuse + DLM. _VegetableMaterial.setTexture(0, textureDLM); _VegetableMaterial.texEnvOpRGB(0, CMaterial::Add); _VegetableMaterial.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor); _VegetableMaterial.texEnvArg1RGB(0, CMaterial::Diffuse, CMaterial::SrcColor); // stage1 RGB is Previous * Texture _VegetableMaterial.texEnvOpRGB(1, CMaterial::Modulate); _VegetableMaterial.texEnvArg0RGB(1, CMaterial::Texture, CMaterial::SrcColor); _VegetableMaterial.texEnvArg1RGB(1, CMaterial::Previous, CMaterial::SrcColor); } else { // reset stage0 (to skip it) _VegetableMaterial.setTexture(0, NULL); // stage1 RGB is Diffuse * Texture _VegetableMaterial.texEnvOpRGB(1, CMaterial::Modulate); _VegetableMaterial.texEnvArg0RGB(1, CMaterial::Texture, CMaterial::SrcColor); _VegetableMaterial.texEnvArg1RGB(1, CMaterial::Diffuse, CMaterial::SrcColor); } // stage1 Alpha is always "Modulate texture with diffuse Alpha" _VegetableMaterial.texEnvOpAlpha(1, CMaterial::Modulate); _VegetableMaterial.texEnvArg0Alpha(1, CMaterial::Texture, CMaterial::SrcAlpha); _VegetableMaterial.texEnvArg1Alpha(1, CMaterial::Diffuse, CMaterial::SrcAlpha); // Render !ZSORT pass //-------------------- // setup material (may have change because of ZSORT / alphaBlend pass) _VegetableMaterial.setBlend(false); _VegetableMaterial.setZWrite(true); _VegetableMaterial.setAlphaTestThreshold(0.5f); /* Prefer sort with Soft / Hard first. Also, Prefer do VBsoft last, for better GPU //ism with Landscape. */ // For both allocators: Hard(1) then Soft(0) for(sint vbHardMode= 1; vbHardMode>=0; vbHardMode--) { // For all renderPass. for(sint rdrPass=0; rdrPass < NL3D_VEGETABLE_NRDRPASS; rdrPass++) { // skip ZSORT rdrPass, done after. if(rdrPass == NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT) continue; // which allocator? CVegetableVBAllocator &vbAllocator= getVBAllocatorForRdrPassAndVBHardMode(rdrPass, vbHardMode); // Do the pass only if there is some vertices to draw. if(vbAllocator.getNumUserVerticesAllocated()>0) { // additional setup to the material bool doubleSided= doubleSidedRdrPass(rdrPass); // set the 2Sided flag in the material _VegetableMaterial.setDoubleSided( doubleSided ); // Activate the unique material. driver->setupMaterial(_VegetableMaterial); // activate Vertex program first. //nlinfo("\nSTARTVP\n%s\nENDVP\n", _VertexProgram[rdrPass]->getProgram().c_str()); nlverify(driver->activeVertexProgram(_VertexProgram[rdrPass])); // Activate the good VBuffer vbAllocator.activate(); // For all visibles clipBlock, render their instance groups. ptrClipBlock= rootToRender; while(ptrClipBlock) { // For all sortBlock of the clipBlock CVegetableSortBlock *ptrSortBlock= ptrClipBlock->_SortBlockList.begin(); while(ptrSortBlock) { // For all igs of the sortBlock CVegetableInstanceGroup *ptrIg= ptrSortBlock->_InstanceGroupList.begin(); while(ptrIg) { // rdrPass CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= ptrIg->_RdrPass[rdrPass]; // if this rdrPass is in same HardMode as we process now. if( (vegetRdrPass.HardMode && vbHardMode==1) || (!vegetRdrPass.HardMode && vbHardMode==0) ) { // Ok, Render the faces. if(vegetRdrPass.NTriangles) { driver->renderSimpleTriangles(&vegetRdrPass.TriangleIndices[0], vegetRdrPass.NTriangles); } } // next ig. ptrIg= (CVegetableInstanceGroup*)ptrIg->Next; } // next sortBlock ptrSortBlock= (CVegetableSortBlock *)(ptrSortBlock->Next); } // next clipBlock to render ptrClipBlock= ptrClipBlock->_RenderNext; } } } } // Render ZSort pass. //-------------------- // Debug Quadrants. /*static vector<CVector> p0DebugLines; static vector<CVector> p1DebugLines; p0DebugLines.clear(); p1DebugLines.clear();*/ // For all Blend model Layers, clear Sort Block list and setup. for(i=0; i<_NumZSortBlendLayers;i++) { // must have been created. nlassert(_ZSortModelLayers[i]); nlassert(_ZSortModelLayersUW[i]); // NB: don't refresh list, it is done in CVegetableBlendLayerModel. // We must do it here, because if vegetableManger::render() is no more called (eg: disabled), // then the models must do nothing. // To get layers correclty sorted from fornt to back, must init their pos // because it is the renderTraversal which sort them. // compute distance to camera of this layer. float layerZ= i * _ZSortLayerDistMax / _NumZSortBlendLayers; // compute position of this layer. CVector pos= viewCenter + frontVector * layerZ; // special setup in the layer. _ZSortModelLayers[i]->setWorldPos(pos); _ZSortModelLayersUW[i]->setWorldPos(pos); } // If some vertices in arrays for ZSort rdrPass if( getVBAllocatorForRdrPassAndVBHardMode(NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, 0).getNumUserVerticesAllocated()>0 || getVBAllocatorForRdrPassAndVBHardMode(NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, 1).getNumUserVerticesAllocated()>0 ) { uint rdrPass= NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT; // sort //------------- // Array for sorting. (static to avoid reallocation) static vector<CSortVSB> sortVegetSbs; sortVegetSbs.clear(); // For all visibles clipBlock ptrClipBlock= rootToRender; while(ptrClipBlock) { // For all sortBlock, prepare to sort them CVegetableSortBlock *ptrSortBlock= ptrClipBlock->_SortBlockList.begin(); while(ptrSortBlock) { // if the sortBlock has some sorted faces to render if(ptrSortBlock->_NTriangles != 0) { // Compute Distance to Viewer. /* NB: compute radial distance (with norm()) instead of linear distance (DotProduct with front vector) get less "ZSort poping". */ CVector dirToSb= ptrSortBlock->_Center - viewCenter; float distToViewer= dirToSb.norm(); // SortKey change if the center is behind the camera. if(dirToSb * frontVectorNormed<0) { ptrSortBlock->_SortKey= - distToViewer; } else { ptrSortBlock->_SortKey= distToViewer; } // Choose the quadrant for this sortBlock sint bestDirIdx= 0; float bestDirVal= -FLT_MAX; // If too near, must take the frontVector as key, to get better sort. // use ptrSortBlock->_SortKey to get correct negative values. if(ptrSortBlock->_SortKey < ptrSortBlock->_Radius) { dirToSb= frontVectorNormed; } // NB: no need to normalize dirToSb, because need only to sort with DP // choose the good list of triangles according to quadrant. for(uint dirIdx=0; dirIdx<NL3D_VEGETABLE_NUM_QUADRANT; dirIdx++) { float dirVal= CVegetableQuadrant::Dirs[dirIdx] * dirToSb; if(dirVal>bestDirVal) { bestDirVal= dirVal; bestDirIdx= dirIdx; } } // set the result. ptrSortBlock->_QuadrantId= bestDirIdx; // insert in list to sort. sortVegetSbs.push_back(CSortVSB(ptrSortBlock)); // Debug Quadrants /*p0DebugLines.push_back(ptrSortBlock->_Center); p1DebugLines.push_back(ptrSortBlock->_Center + CVegetableQuadrant::Dirs[bestDirIdx]);*/ } // next sortBlock ptrSortBlock= (CVegetableSortBlock *)(ptrSortBlock->Next); } // next clipBlock to render ptrClipBlock= ptrClipBlock->_RenderNext; } // sort! // QSort. (I tried, better than radix sort, guckk!!) sort(sortVegetSbs.begin(), sortVegetSbs.end()); // setup material for this rdrPass. NB: rendered after (in LayerModels). //------------- bool doubleSided= doubleSidedRdrPass(rdrPass); // set the 2Sided flag in the material _VegetableMaterial.setDoubleSided( doubleSided ); // setup the unique material. _VegetableMaterial.setBlend(true); _VegetableMaterial.setZWrite(false); // leave AlphaTest but still kick low alpha values (for fillRate performance) _VegetableMaterial.setAlphaTestThreshold(0.1f); // order them in Layers. //------------- // render from back to front, to keep correct Z order in a single layer. for(uint i=0; i<sortVegetSbs.size();i++) { CVegetableSortBlock *ptrSortBlock= sortVegetSbs[i].Sb; float z= ptrSortBlock->_SortKey; // compute in which layer must store this SB. z= z*_NumZSortBlendLayers / _ZSortLayerDistMax; // Avoid a floor(), using an OptFastFloor, but without the OptFastFloorBegin() End() group. // => avoid the imprecision with such a trick; *256, then divide the integer by 256. sint layer= NLMISC::OptFastFloor(z*256) >> 8; clamp(layer, 0, (sint)_NumZSortBlendLayers-1); // Range in correct layer, according to water ordering if(ptrSortBlock->_UnderWater) // range in the correct layermodel (NB: keep the same layer internal order). _ZSortModelLayersUW[layer]->SortBlocks.push_back(ptrSortBlock); else _ZSortModelLayers[layer]->SortBlocks.push_back(ptrSortBlock); } } // Quit //-------------------- // disable VertexProgram. driver->activeVertexProgram(NULL); // restore Fog. driver->enableFog(bkupFog); // Debug Quadrants /*for(uint l=0; l<p0DebugLines.size();l++) { CVector dv= CVector::K; CDRU::drawLine(p0DebugLines[l]+dv, p1DebugLines[l]+dv, CRGBA(255,0,0), *driver); }*/ // profile: compute number of triangles rendered with vegetable manager. driver->profileRenderedPrimitives(ppIn, ppOut); _NumVegetableFaceRendered= ppOut.NTriangles-precNTriRdr; }

void NL3D::CVegetableManager::reserveIgAddInstances (  CVegetableInstanceGroupReserve &  vegetIgReserve, CVegetableShape *  shape, TVegetableWater  vegetWaterState, uint  numInstances )

reserve some instance space in an Ig. nothing is really done here, after doing this for all shapes of your ig, you must call reserveIgCompile() Parameters: vegetIgReserve  the object where space required for the ig is added Definition at line 856 of file vegetable_manager.cpp. References NL3D::CVegetableInstanceGroupReserve::_RdrPass, NL3D::CVertexBuffer::getNumVertices(), getRdrPassInfoForShape(), NL3D::CVegetableInstanceGroupReserve::CVegetableRdrPass::NLightedInstances, NL3D::CVegetableInstanceGroupReserve::CVegetableRdrPass::NTriangles, NL3D::CVegetableInstanceGroupReserve::CVegetableRdrPass::NVertices, NL3D::CVegetableShape::TriangleIndices, uint, and NL3D::CVegetableShape::VB. Referenced by NL3D::CVegetable::reserveIgAddInstances(). { bool instanceLighted; bool instanceDoubleSided; bool instanceZSort; bool destLighted; bool precomputeLighting; // get correct rdrPass / info uint rdrPass; rdrPass= getRdrPassInfoForShape(shape, vegetWaterState, instanceLighted, instanceDoubleSided, instanceZSort, destLighted, precomputeLighting); // veget rdrPass CVegetableInstanceGroupReserve::CVegetableRdrPass &vegetRdrPass= vegetIgReserve._RdrPass[rdrPass]; // Reserve space in the rdrPass. vegetRdrPass.NVertices+= numInstances * shape->VB.getNumVertices(); vegetRdrPass.NTriangles+= numInstances * shape->TriangleIndices.size()/3; // if the instances are lighted, reserve space for lighting updates if(instanceLighted) vegetRdrPass.NLightedInstances+= numInstances; }

void NL3D::CVegetableManager::reserveIgCompile (  CVegetableInstanceGroup *  ig, const CVegetableInstanceGroupReserve &  vegetIgReserve )

reserve the space in the ig. nlassert() if the ig is not empty. See also: reserveIgAddInstances() Definition at line 882 of file vegetable_manager.cpp. References NL3D::CVegetableInstanceGroupReserve::_RdrPass, NL3D::CVegetableInstanceGroup::_RdrPass, NL3D::CVegetableInstanceGroup::_TriangleQuadrantOrderArray, NL3D::CVegetableInstanceGroup::_TriangleQuadrantOrderNumTriangles, NL3D::CVegetableInstanceGroup::_TriangleQuadrantOrders, NLMISC::CObjectVector< sint16, false >::getPtr(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::LightedInstances, NL3D_VEGETABLE_NRDRPASS, NL3D_VEGETABLE_NUM_QUADRANT, NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, nlassert, NLMISC::CObjectVector< sint16, false >::resize(), NLMISC::CObjectVector< CVegetableLightedInstance >::resize(), NLMISC::CObjectVector< uint32, false >::resize(), sint16, NLMISC::CObjectVector< sint16, false >::size(), NLMISC::CObjectVector< CVegetableLightedInstance >::size(), NLMISC::CObjectVector< uint32, false >::size(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::TriangleIndices, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::TriangleLocalIndices, uint, and NL3D::CVegetableInstanceGroup::CVegetableRdrPass::Vertices. Referenced by NL3D::CPatch::generateTileVegetable(). { uint rdrPass; // Check. //=========== // For all rdrPass of the ig, check empty for(rdrPass= 0; rdrPass<NL3D_VEGETABLE_NRDRPASS; rdrPass++) { CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= ig->_RdrPass[rdrPass]; nlassert(vegetRdrPass.TriangleIndices.size()==0); nlassert(vegetRdrPass.TriangleLocalIndices.size()==0); nlassert(vegetRdrPass.Vertices.size()==0); nlassert(vegetRdrPass.LightedInstances.size()==0); } // Do the same for all quadrants of the zsort rdrPass. nlassert(ig->_TriangleQuadrantOrderArray.size()==0); nlassert(ig->_TriangleQuadrantOrderNumTriangles==0); // Reserve. //=========== // For all rdrPass of the ig, reserve. for(rdrPass= 0; rdrPass<NL3D_VEGETABLE_NRDRPASS; rdrPass++) { CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= ig->_RdrPass[rdrPass]; uint numVertices= vegetIgReserve._RdrPass[rdrPass].NVertices; uint numTris= vegetIgReserve._RdrPass[rdrPass].NTriangles; uint numLightedInstances= vegetIgReserve._RdrPass[rdrPass].NLightedInstances; // reserve triangles indices and vertices for this rdrPass. vegetRdrPass.TriangleIndices.resize(numTris*3); vegetRdrPass.TriangleLocalIndices.resize(numTris*3); vegetRdrPass.Vertices.resize(numVertices); // reserve ligthedinstances space. vegetRdrPass.LightedInstances.resize(numLightedInstances); } // Reserve space for the zsort rdrPass sorting. uint numZSortTris= vegetIgReserve._RdrPass[NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT].NTriangles; // allocate sufficient space for all quadrants (1 alloc for all quadrants). ig->_TriangleQuadrantOrderArray.resize(numZSortTris * NL3D_VEGETABLE_NUM_QUADRANT); // And init ptrs. if(numZSortTris>0) { sint16 *start= ig->_TriangleQuadrantOrderArray.getPtr(); // init ptr to each qaudrant for(uint i=0; i<NL3D_VEGETABLE_NUM_QUADRANT; i++) { ig->_TriangleQuadrantOrders[i]= start + i*numZSortTris; } } }

void NL3D::CVegetableManager::resetNumVegetableFaceRendered (   )

set to 0 the number of faces rendered Definition at line 2166 of file vegetable_manager.cpp. References _NumVegetableFaceRendered. Referenced by NL3D::CLandscape::render(). { _NumVegetableFaceRendered= 0; }

void NL3D::CVegetableManager::setDirectionalLight (  const CRGBA &  ambient, const CRGBA &  diffuse, const CVector &  light )

setup the directional light Definition at line 1612 of file vegetable_manager.cpp. References _DirectionalLight, _GlobalAmbient, _GlobalDiffuse, and NLMISC::CVector::normalize(). Referenced by NL3D::CLandscape::setupVegetableLighting(). { _DirectionalLight= light; _DirectionalLight.normalize(); // Setup ambient/Diffuse. _GlobalAmbient= ambient; _GlobalDiffuse= diffuse; }

void NL3D::CVegetableManager::setTime (  double  time  )

set the current Time (in seconds). For Wind animation Definition at line 2206 of file vegetable_manager.cpp. Referenced by NL3D::CLandscape::setVegetableTime(). { // copy time _Time= time; }

void NL3D::CVegetableManager::setUpdateLightingFrequency (  float  freq  )

set the frequency of lighting update. If freq==1, ALL lighted igs are updated each second. e.g: if 1/20, then every 20 seconds, all Igs are updated. If you set 0, no update will be done at all (this is the default setup!!). Definition at line 2280 of file vegetable_manager.cpp. Referenced by NL3D::CLandscape::setVegetableUpdateLightingFrequency(). { freq= max(freq, 0.f); _ULFrequency= freq; }

void NL3D::CVegetableManager::setUpdateLightingTime (  double  time  )

set the vegetable manager System Time (in seconds) This time is used for lighting update, and is independent of setTime() Definition at line 2221 of file vegetable_manager.cpp. Referenced by NL3D::CLandscape::setVegetableUpdateLightingTime(). { _ULTime= time; }

void NL3D::CVegetableManager::setupRenderStateForBlendLayerModel (  IDriver *  driver  )  [private]

called by CVegetableBlendLayerModel. Definition at line 2134 of file vegetable_manager.cpp. References _BkupFog, _ManagerMatrix, _VegetableMaterial, NL3D::IDriver::activeVertexProgram(), doubleSidedRdrPass(), NL3D::IDriver::enableFog(), NL3D::IDriver::fogEnabled(), NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT, nlverify, NL3D::IDriver::setupMaterial(), NL3D::IDriver::setupModelMatrix(), setupVertexProgramConstants(), and uint. Referenced by NL3D::CVegetableBlendLayerModel::render(). { // Setup Global. //============= // disable fog, for faster VP. _BkupFog= driver->fogEnabled(); driver->enableFog(false); // set model matrix to the manager matrix. driver->setupModelMatrix(_ManagerMatrix); // setup VP constants. setupVertexProgramConstants(driver); // Setup RdrPass. //============= uint rdrPass= NL3D_VEGETABLE_RDRPASS_UNLIT_2SIDED_ZSORT; // setup doubleSidedmaterial for this rdrPass. bool doubleSided= doubleSidedRdrPass(rdrPass); // Activate the unique material (correclty setuped for AlphaBlend in render()). driver->setupMaterial(_VegetableMaterial); // activate Vertex program first. //nlinfo("\nSTARTVP\n%s\nENDVP\n", _VertexProgram[rdrPass]->getProgram().c_str()); nlverify(driver->activeVertexProgram(_VertexProgram[rdrPass])); }

void NL3D::CVegetableManager::setupVertexProgramConstants (  IDriver *  driver  )  [private]

setup the vertexProgram constants. Definition at line 1664 of file vegetable_manager.cpp. References _AngleAxis, _DirectionalLight, _ViewCenter, _WindAnimTime, _WindBendMin, _WindDeltaTable, _WindPower, _WindTable, NL3D_VEGETABLE_BLOCK_BLEND_TRANSITION_DIST, NL3D_VEGETABLE_VP_LUT_SIZE, NLMISC::Pi, NL3D::IDriver::setConstant(), NL3D::IDriver::setConstantMatrix(), uint, NLMISC::CVector2f::x, NLMISC::CVector::x, NLMISC::CVector2f::y, NLMISC::CVector::y, and NLMISC::CVector::z. Referenced by render(), and setupRenderStateForBlendLayerModel(). { // Standard // setup VertexProgram constants. // c[0..3] take the ModelViewProjection Matrix. After setupModelMatrix(); driver->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity); // c[4..7] take the ModelView Matrix. After setupModelMatrix(); driver->setConstantMatrix(4, IDriver::ModelView, IDriver::Identity); // c[8] take usefull constants. driver->setConstant(8, 0, 1, 0.5f, 2); // c[9] take normalized directional light driver->setConstant(9, _DirectionalLight); // c[10] take pos of camera driver->setConstant(10, _ViewCenter); // c[11] take factor for Blend formula driver->setConstant(11, -1.f/NL3D_VEGETABLE_BLOCK_BLEND_TRANSITION_DIST, 0, 0, 0); // Bend. // c[16]= quaternion axis. w==1, and z must be 0 driver->setConstant( 16, _AngleAxis.x, _AngleAxis.y, _AngleAxis.z, 1); // c[17]= {timeAnim, WindPower, WindPower*(1-WindBendMin)/2, 0)} driver->setConstant( 17, (float)_WindAnimTime, _WindPower, _WindPower*(1-_WindBendMin)/2, 0 ); // c[18]= High order Taylor cos coefficient: { -1/2, 1/24, -1/720, 1/40320 } driver->setConstant( 18, -1/2.f, 1/24.f, -1/720.f, 1/40320.f ); // c[19]= Low order Taylor cos coefficient: { 1, -1/2, 1/24, -1/720 } driver->setConstant( 19, 1, -1/2.f, 1/24.f, -1/720.f ); // c[20]= Low order Taylor sin coefficient: { 1, -1/6, 1/120, -1/5040 } driver->setConstant( 20, 1, -1/6.f, 1/120.f, -1/5040.f ); // c[21]= Special constant vector for quatToMatrix: { 0, 1, -1, 0 } driver->setConstant( 21, 0.f, 1.f, -1.f, 0.f); // c[22]= {0.5f, Pi, 2*Pi, 1/(2*Pi)} driver->setConstant( 22, 0.5f, (float)Pi, (float)(2*Pi), (float)(1/(2*Pi)) ); // c[23]= {NL3D_VEGETABLE_VP_LUT_SIZE, 0, 0, 0}. NL3D_VEGETABLE_VP_LUT_SIZE==64. driver->setConstant( 23, NL3D_VEGETABLE_VP_LUT_SIZE, 0.f, 0.f, 0.f ); // Fill constant. Start at 32. for(uint i=0; i<NL3D_VEGETABLE_VP_LUT_SIZE; i++) { CVector2f cur= _WindTable[i]; CVector2f delta= _WindDeltaTable[i]; driver->setConstant( 32+i, cur.x, cur.y, delta.x, delta.y ); } }

void NL3D::CVegetableManager::setWind (  const CVector &  windDir, float  windFreq, float  windPower, float  windBendMin )

set the Wind for animation. All thoses variables may be modified each frame without penalty. Parameters: windDir  is the direction of the wind. NB: only XY direction is kept. windFreq  is the frequency for the animation (speed) windPower  is the power of the wind, and is a factor (0..1) of Bend windBendMin  is a value in (0..1) which indicate how much the vegetables are bended at minimum (for very powerfull wind) Definition at line 2192 of file vegetable_manager.cpp. References _WindBendMin, _WindDirection, _WindFrequency, _WindPower, NLMISC::clamp(), NLMISC::CVector::normalize(), and NLMISC::CVector::z. Referenced by NL3D::CLandscape::setVegetableWind(). { // Keep only XY component of the Wind direction (because VP only support z==0 quaternions). _WindDirection= windDir; _WindDirection.z= 0; _WindDirection.normalize(); // copy setup _WindFrequency= windFreq; _WindPower= windPower; _WindBendMin= windBendMin; clamp(_WindBendMin, 0, 1); }

void NL3D::CVegetableManager::swapIgRdrPassHardMode (  CVegetableInstanceGroup *  , uint  rdrPass )  [private]

swap the RdrPass type (hard or soft) of the rdrPass of an instance group. vertices are allocated in other VBallocator, copied and freed in the old VBallocator. Definition at line 1496 of file vegetable_manager.cpp. References NL3D::CVegetableInstanceGroup::_RdrPass, NL3D::CVegetableVBAllocator::allocateVertex(), NL3D::CVegetableVBAllocator::deleteVertex(), NL3D::CVegetableVBAllocator::flushVertex(), NL3D::CVegetableVBAllocator::getSoftwareVertexBuffer(), getVBAllocatorForRdrPassAndVBHardMode(), NL3D::CVegetableVBAllocator::getVertexPointer(), NL3D::CVertexBuffer::getVertexSize(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::HardMode, nlassert, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::NTriangles, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::NVertices, NLMISC::CObjectVector< uint32, false >::size(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::TriangleIndices, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::TriangleLocalIndices, uint, and NL3D::CVegetableInstanceGroup::CVegetableRdrPass::Vertices. Referenced by addInstance(). { CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= ig->_RdrPass[rdrPass]; // the allocator where vertices come from CVegetableVBAllocator &srcAllocator= getVBAllocatorForRdrPassAndVBHardMode(rdrPass, vegetRdrPass.HardMode); // the allocator where vertices will go CVegetableVBAllocator &dstAllocator= getVBAllocatorForRdrPassAndVBHardMode(rdrPass, !vegetRdrPass.HardMode); // vertex size uint vbSize= srcAllocator.getSoftwareVertexBuffer().getVertexSize(); nlassert(vbSize == dstAllocator.getSoftwareVertexBuffer().getVertexSize()); // for all vertices of the IG, change of VBAllocator uint i; // Do it only for current Vertices setuped!!! because a swapIgRdrPassHardMode awlays arise when the ig is // in construcion. // Hence here, we may have vegetRdrPass.NVertices < vegetRdrPass.Vertices.size() !!! for(i=0;i<vegetRdrPass.NVertices;i++) { // get idx in src allocator. uint srcId= vegetRdrPass.Vertices[i]; // allocate a verex in the dst allocator. uint dstId= dstAllocator.allocateVertex(); // copy from VBsoft of src to dst. void *vbSrc= srcAllocator.getVertexPointer(srcId); void *vbDst= dstAllocator.getVertexPointer(dstId); memcpy(vbDst, vbSrc, vbSize); // release src vertex. srcAllocator.deleteVertex(srcId); // and copy new dest id in Vertices array. vegetRdrPass.Vertices[i]= dstId; // and flush this vertex into VBHard (if dst is aVBHard). dstAllocator.flushVertex(dstId); } // For all triangles, bind correct triangles. nlassert(vegetRdrPass.TriangleIndices.size() == vegetRdrPass.TriangleLocalIndices.size()); // Do it only for current Triangles setuped!!! same reason as vertices // For all setuped triangles indices for(i=0;i<vegetRdrPass.NTriangles*3;i++) { // get the index in Vertices. uint localVid= vegetRdrPass.TriangleLocalIndices[i]; // get the index in new VBufffer (dstAllocator), and copy to TriangleIndices vegetRdrPass.TriangleIndices[i]= vegetRdrPass.Vertices[localVid]; } // Since change is made, flag the IG rdrpass vegetRdrPass.HardMode= !vegetRdrPass.HardMode; }

void NL3D::CVegetableManager::unlockBuffers (   )

unlock any AGP vertex buffers Definition at line 1633 of file vegetable_manager.cpp. References _VBHardAllocator, _VBSoftAllocator, uint, and NL3D::CVegetableVBAllocator::unlockBuffer(). Referenced by NL3D::CLandscape::unlockBuffers(). { // unlock all buffers for(uint i=0; i <CVegetableVBAllocator::VBTypeCount; i++) { _VBHardAllocator[i].unlockBuffer(); _VBSoftAllocator[i].unlockBuffer(); } }

void NL3D::CVegetableManager::updateDriver (  IDriver *  driver  )

must give a driver to the vegetableManager, before any addInstance(). Definition at line 1569 of file vegetable_manager.cpp. References _LastDriver, _VBHardAllocator, _VBSoftAllocator, initVertexProgram(), NL3D_VEGETABLE_NRDRPASS, uint, and NL3D::CVegetableVBAllocator::updateDriver(). Referenced by render(), and NL3D::CLandscape::updateGlobalsAndLockBuffers(). { // update all driver uint i; for(i=0; i <CVegetableVBAllocator::VBTypeCount; i++) { _VBHardAllocator[i].updateDriver(driver); _VBSoftAllocator[i].updateDriver(driver); } // if driver changed, recreate vertex programs if (driver != _LastDriver) { _LastDriver = driver; for(i=0; i <NL3D_VEGETABLE_NRDRPASS; i++) { initVertexProgram(i); } } }

uint NL3D::CVegetableManager::updateInstanceLighting (  CVegetableInstanceGroup *  ig, uint  rdrPassId, uint  instanceId )  [private]

update part of an ig. Do not use/modify _UL* return number of vertices processed (nb vertices of the shape) Definition at line 2354 of file vegetable_manager.cpp. References _DirectionalLight, _GlobalAmbient, _GlobalDiffuse, NL3D::CVegetableInstanceGroup::_RdrPass, NLMISC::CRGBA::A, NL3D::CVegetableShape::BestSidedPreComputeLighting, NL3D::CVegetableLightEx::Color, NL3D::computeVegetVertexLighting(), NL3D::computeVegetVertexLightingForceBestSided(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::DlmUV, NL3D::CVegetableShape::DoubleSided, NL3D::CVegetableVBAllocator::flushVertex(), NL3D::CVertexBuffer::getNormalOff(), NLMISC::CObjectVector< uint32, false >::getPtr(), NL3D::CVegetableVBAllocator::getSoftwareVertexBuffer(), NL3D::CVertexBuffer::getValueOffEx(), getVBAllocatorForRdrPassAndVBHardMode(), NL3D::CVertexBuffer::getVertexCoordPointer(), NL3D::CVegetableVBAllocator::getVertexPointer(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::HardMode, NL3D::CVegetableShape::InstanceVertices, NL3D::CVegetableShape::Lighted, NL3D::CVegetableInstanceGroup::CVegetableRdrPass::LightedInstances, NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::MatAmbient, NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::MatDiffuse, NLMISC::CRGBA::modulateFromColorRGBOnly(), NLMISC::CMatrix::mulVector(), NL3D_VEGETABLE_NRDRPASS, NL3D_VEGETABLE_VPPOS_COLOR0, NL3D_VEGETABLE_VPPOS_COLOR1, nlassert, NLMISC::CVector::normalize(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::NormalMat, NL3D::CVegetableLightEx::NumLights, NL3D::CVegetableShape::PreComputeLighting, NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::Shape, sint, NLMISC::CObjectVector< CVegetableLightedInstance >::size(), NL3D::CVegetableInstanceGroup::CVegetableLightedInstance::StartIdInRdrPass, NL3D::CVegetableUV8::U, uint, uint32, uint8, NL3D::CVegetableUV8::V, NL3D::CVegetableShape::VB, NL3D::CVegetableInstanceGroup::VegetableLightEx, and NL3D::CVegetableInstanceGroup::CVegetableRdrPass::Vertices. Referenced by updateLightingIGPart(). { nlassert(ig); // get the rdrPass. nlassert(rdrPassId<NL3D_VEGETABLE_NRDRPASS); CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= ig->_RdrPass[rdrPassId]; // get the lighted instance. nlassert(instanceId<vegetRdrPass.LightedInstances.size()); CVegetableInstanceGroup::CVegetableLightedInstance &vegetLI= vegetRdrPass.LightedInstances[instanceId]; // get the shape CVegetableShape *shape= vegetLI.Shape; // it must be lighted. nlassert(shape->Lighted); bool instanceLighted= true; // get ref on the vegetLex. CVegetableLightEx &vegetLex= ig->VegetableLightEx; // Color of pointLights modulated by diffuse. CRGBA diffusePL[2]; if(vegetLex.NumLights>=1) { diffusePL[0].modulateFromColorRGBOnly(vegetLI.MatDiffuse, vegetLex.Color[0]); if(vegetLex.NumLights>=2) { diffusePL[1].modulateFromColorRGBOnly(vegetLI.MatDiffuse, vegetLex.Color[1]); } } // Recompute lighting //=========== // setup for this instance. //--------- // 2Sided bool instanceDoubleSided= shape->DoubleSided; // Precompute lighting or not?? bool precomputeLighting= instanceLighted && shape->PreComputeLighting; // bestSided Precompute lighting or not?? bool bestSidedPrecomputeLighting= precomputeLighting && shape->BestSidedPreComputeLighting; // destLighted? bool destLighted= instanceLighted && !shape->PreComputeLighting; // Diffuse and ambient, modulated by current GlobalAmbient and GlobalDiffuse. CRGBA primaryRGBA, secondaryRGBA; primaryRGBA.modulateFromColorRGBOnly(vegetLI.MatDiffuse, _GlobalDiffuse); secondaryRGBA.modulateFromColorRGBOnly(vegetLI.MatAmbient, _GlobalAmbient); // get normal matrix CMatrix &normalMat= vegetLI.NormalMat; // array of vertex id to update uint32 *ptrVid= vegetRdrPass.Vertices.getPtr() + vegetLI.StartIdInRdrPass; uint numVertices= shape->InstanceVertices.size(); // Copy Dynamic Lightmap UV in Alpha part (save memory for an extra cost of 1 VP instruction) primaryRGBA.A= vegetLI.DlmUV.U; secondaryRGBA.A= vegetLI.DlmUV.V; // get VertexBuffer info. CVegetableVBAllocator *allocator; allocator= &getVBAllocatorForRdrPassAndVBHardMode(rdrPassId, vegetRdrPass.HardMode); const CVertexBuffer &dstVBInfo= allocator->getSoftwareVertexBuffer(); uint srcNormalOff= (instanceLighted? shape->VB.getNormalOff() : 0); uint dstColor0Off= dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_COLOR0); uint dstColor1Off= dstVBInfo.getValueOffEx(NL3D_VEGETABLE_VPPOS_COLOR1); // For all vertices, recompute lighting. //--------- for(sint i=0; i<(sint)numVertices;i++) { // get the Vertex in the VB. uint vid= ptrVid[i]; // store in tmp shape. shape->InstanceVertices[i]= vid; // Fill this vertex. uint8 *srcPtr= (uint8*)shape->VB.getVertexCoordPointer(i); uint8 *dstPtr= (uint8*)allocator->getVertexPointer(vid); // if !precomputeLighting (means destLighted...) if(!precomputeLighting) { // just copy the primary and secondary color *(CRGBA*)(dstPtr + dstColor0Off)= primaryRGBA; *(CRGBA*)(dstPtr + dstColor1Off)= secondaryRGBA; } else { nlassert(!destLighted); // compute normal. CVector rotNormal= normalMat.mulVector( *(CVector*)(srcPtr + srcNormalOff) ); // must normalize() because scale is possible. rotNormal.normalize(); // Do the compute. if(!bestSidedPrecomputeLighting) { computeVegetVertexLighting(rotNormal, _DirectionalLight, primaryRGBA, secondaryRGBA, vegetLex, diffusePL, (CRGBA*)(dstPtr + dstColor0Off) ); } else { computeVegetVertexLightingForceBestSided(rotNormal, _DirectionalLight, primaryRGBA, secondaryRGBA, vegetLex, diffusePL, (CRGBA*)(dstPtr + dstColor0Off) ); } } // flust the vertex in AGP. allocator->flushVertex(vid); } // numVertices vertices are updated return numVertices; }

void NL3D::CVegetableManager::updateLighting (   )

update the lighting of Igs, within a certain amount of time. You MUST enclose calls to updateLighting() with lockBuffers() / unlockBuffers(). Definition at line 2228 of file vegetable_manager.cpp. References _ULNTotalVertices, _ULNVerticesToUpdate, doUpdateLighting(), and min. Referenced by NL3D::CLandscape::refine(). { // first time in this method?? if(!_ULPrecTimeInit) { _ULPrecTimeInit= true; _ULPrecTime= _ULTime; } // compute delta time from last update. float dt= float(_ULTime - _ULPrecTime); _ULPrecTime= _ULTime; // compute number of vertices to update. _ULNVerticesToUpdate+= dt*_ULFrequency * _ULNTotalVertices; // maximize, so at max, it computes all Igs, just one time. _ULNVerticesToUpdate= min(_ULNVerticesToUpdate, (float)_ULNTotalVertices); // go. doUpdateLighting(); }

void NL3D::CVegetableManager::updateLightingAll (   )

like updateLighting(), but update ALL vegetable You MUST enclose calls to updateLighting() with lockBuffers() / unlockBuffers(). Definition at line 2251 of file vegetable_manager.cpp. References _ULNTotalVertices, _ULNVerticesToUpdate, and doUpdateLighting(). Referenced by NL3D::CLandscape::updateLightingAll(). { // maximize, so at max, it computes all Igs _ULNVerticesToUpdate= (float)_ULNTotalVertices; // go. doUpdateLighting(); }

bool NL3D::CVegetableManager::updateLightingIGPart (   )  [private]

update part of the RootIg, according to _ULNVerticesToUpdate (while > 0) if all Ig is updated, return true and _ULCurrentIgRdrPass and _ULCurrentIgInstance is updated. Definition at line 2288 of file vegetable_manager.cpp. References NL3D::CVegetableInstanceGroup::_RdrPass, _ULCurrentIgInstance, _ULCurrentIgRdrPass, _ULNVerticesToUpdate, _ULRootIg, NL3D::CVegetableLightEx::computeCurrentColors(), NL3D::CVegetableInstanceGroup::CVegetableRdrPass::LightedInstances, NL3D_VEGETABLE_NRDRPASS, nlassert, NLMISC::CObjectVector< CVegetableLightedInstance >::size(), updateInstanceLighting(), and NL3D::CVegetableInstanceGroup::VegetableLightEx. Referenced by doUpdateLighting(). { nlassert(_ULRootIg); // First, update lighting info global to the ig, ie update current // colros of the PointLights which influence the ig. _ULRootIg->VegetableLightEx.computeCurrentColors(); // while there is some vertices to update while(_ULNVerticesToUpdate>0) { // if all rdrPass of the ig are processed. if(_ULCurrentIgRdrPass>= NL3D_VEGETABLE_NRDRPASS) { // All this Ig is updated. _ULCurrentIgRdrPass= 0; _ULCurrentIgInstance= 0; // skip to next Ig. return true; } CVegetableInstanceGroup::CVegetableRdrPass &vegetRdrPass= _ULRootIg->_RdrPass[_ULCurrentIgRdrPass]; // if all instances are processed for this pass (especially if size()==0 !!) if(_ULCurrentIgInstance>= vegetRdrPass.LightedInstances.size()) { // skip to the next rdrPass. _ULCurrentIgRdrPass++; _ULCurrentIgInstance= 0; continue; } // Process this instance. _ULNVerticesToUpdate-= updateInstanceLighting(_ULRootIg, _ULCurrentIgRdrPass, _ULCurrentIgInstance); // next instance. _ULCurrentIgInstance++; // if all instances are processed for this pass if(_ULCurrentIgInstance>= vegetRdrPass.LightedInstances.size()) { // skip to the next rdrPass. _ULCurrentIgRdrPass++; _ULCurrentIgInstance= 0; } } // If all rdrPass of the ig are processed. if(_ULCurrentIgRdrPass>= NL3D_VEGETABLE_NRDRPASS) { // All this Ig is updated. _ULCurrentIgRdrPass= 0; _ULCurrentIgInstance= 0; // skip to next Ig. return true; } else { // The Ig is not entirely updated. return false; } }

---

Friends And Related Function Documentation

friend class CVegetableBlendLayerModel [friend]

Definition at line 287 of file vegetable_manager.h.

---

Field Documentation

CVector NL3D::CVegetableManager::_AngleAxis [private]

Definition at line 378 of file vegetable_manager.h. Referenced by render(), and setupVertexProgramConstants().

bool NL3D::CVegetableManager::_BkupFog [private]

Definition at line 380 of file vegetable_manager.h. Referenced by exitRenderStateForBlendLayerModel(), and setupRenderStateForBlendLayerModel().

CTessList<CVegetableClipBlock> NL3D::CVegetableManager::_ClipBlockList [private]

Definition at line 294 of file vegetable_manager.h. Referenced by createIg(), deleteIg(), and render().

NLMISC::CBlockMemory<CVegetableClipBlock> NL3D::CVegetableManager::_ClipBlockMemory [private]

Definition at line 289 of file vegetable_manager.h. Referenced by createClipBlock(), and deleteClipBlock().

float NL3D::CVegetableManager::_CosTable[NL3D_VEGETABLE_VP_LUT_SIZE] [private]

Definition at line 366 of file vegetable_manager.h.

CVector NL3D::CVegetableManager::_DirectionalLight [private]

Definition at line 316 of file vegetable_manager.h. Referenced by addInstance(), CVegetableManager(), setDirectionalLight(), setupVertexProgramConstants(), and updateInstanceLighting().

CTessList<CVegetableClipBlock> NL3D::CVegetableManager::_EmptyClipBlockList [private]

Definition at line 296 of file vegetable_manager.h. Referenced by createClipBlock(), createIg(), deleteClipBlock(), and deleteIg().

NLMISC::CRGBA NL3D::CVegetableManager::_GlobalAmbient [private]

Definition at line 317 of file vegetable_manager.h. Referenced by addInstance(), CVegetableManager(), setDirectionalLight(), and updateInstanceLighting().

NLMISC::CRGBA NL3D::CVegetableManager::_GlobalDiffuse [private]

Definition at line 318 of file vegetable_manager.h. Referenced by addInstance(), CVegetableManager(), setDirectionalLight(), and updateInstanceLighting().

NLMISC::CBlockMemory<CVegetableInstanceGroup> NL3D::CVegetableManager::_InstanceGroupMemory [private]

Definition at line 291 of file vegetable_manager.h. Referenced by createIg(), and deleteIg().

NLMISC::CRefPtr<IDriver> NL3D::CVegetableManager::_LastDriver [private]

Definition at line 448 of file vegetable_manager.h. Referenced by initVertexProgram(), and updateDriver().

NLMISC::CMatrix NL3D::CVegetableManager::_ManagerMatrix [private]

Definition at line 382 of file vegetable_manager.h. Referenced by render(), and setupRenderStateForBlendLayerModel().

uint NL3D::CVegetableManager::_NumVegetableFaceRendered [private]

profile Definition at line 322 of file vegetable_manager.h. Referenced by CVegetableManager(), getNumVegetableFaceRendered(), render(), NL3D::CVegetableBlendLayerModel::render(), and resetNumVegetableFaceRendered().

uint NL3D::CVegetableManager::_NumZSortBlendLayers [private]

For Alpha Blend rdrPass, ordering into layers. Definition at line 392 of file vegetable_manager.h. Referenced by createVegetableBlendLayersModels(), CVegetableManager(), render(), and ~CVegetableManager().

TShapeMap NL3D::CVegetableManager::_ShapeMap [private]

Definition at line 302 of file vegetable_manager.h.

NLMISC::CBlockMemory<CVegetableSortBlock> NL3D::CVegetableManager::_SortBlockMemory [private]

Definition at line 290 of file vegetable_manager.h. Referenced by createSortBlock(), and deleteSortBlock().

double NL3D::CVegetableManager::_Time [private]

Definition at line 360 of file vegetable_manager.h.

uint NL3D::CVegetableManager::_ULCurrentIgInstance [private]

update lighting according to _ULNVerticesToUpdate Definition at line 428 of file vegetable_manager.h. Referenced by CVegetableManager(), deleteIg(), and updateLightingIGPart().

uint NL3D::CVegetableManager::_ULCurrentIgRdrPass [private]

Current instance to render in the first ig to update: rdrpass/instanceId. Definition at line 427 of file vegetable_manager.h. Referenced by CVegetableManager(), deleteIg(), and updateLightingIGPart().

float NL3D::CVegetableManager::_ULFrequency [private]

Frequency of update. Definition at line 419 of file vegetable_manager.h.

uint NL3D::CVegetableManager::_ULNTotalVertices [private]

Sum of all ig vertices to update. Definition at line 423 of file vegetable_manager.h. Referenced by addInstance(), CVegetableManager(), deleteIg(), updateLighting(), and updateLightingAll().

float NL3D::CVegetableManager::_ULNVerticesToUpdate [private]

Current number of vertices to update. If negative, I have some advance. Definition at line 421 of file vegetable_manager.h. Referenced by CVegetableManager(), doUpdateLighting(), updateLighting(), updateLightingAll(), and updateLightingIGPart().

double NL3D::CVegetableManager::_ULPrecTime [private]

NB: we update at the precision of a shape (a dozen of vertices). Definition at line 414 of file vegetable_manager.h.

bool NL3D::CVegetableManager::_ULPrecTimeInit [private]

update lighting according to _ULNVerticesToUpdate Definition at line 415 of file vegetable_manager.h.

CVegetableInstanceGroup* NL3D::CVegetableManager::_ULRootIg [private]

the priority list of ig to update Definition at line 425 of file vegetable_manager.h. Referenced by addInstance(), CVegetableManager(), deleteIg(), doUpdateLighting(), and updateLightingIGPart().

double NL3D::CVegetableManager::_ULTime [private]

update lighting according to _ULNVerticesToUpdate Definition at line 416 of file vegetable_manager.h.

CVegetableVBAllocator NL3D::CVegetableManager::_VBHardAllocator[CVegetableVBAllocator::VBTypeCount] [private]

Definition at line 306 of file vegetable_manager.h. Referenced by CVegetableManager(), getVBAllocatorForRdrPassAndVBHardMode(), lockBuffers(), unlockBuffers(), and updateDriver().

CVegetableVBAllocator NL3D::CVegetableManager::_VBSoftAllocator[CVegetableVBAllocator::VBTypeCount] [private]

Definition at line 308 of file vegetable_manager.h. Referenced by CVegetableManager(), getVBAllocatorForRdrPassAndVBHardMode(), lockBuffers(), unlockBuffers(), and updateDriver().

CMaterial NL3D::CVegetableManager::_VegetableMaterial [private]

Definition at line 314 of file vegetable_manager.h. Referenced by CVegetableManager(), loadTexture(), render(), and setupRenderStateForBlendLayerModel().

CVertexProgram* NL3D::CVegetableManager::_VertexProgram[NL3D_VEGETABLE_NRDRPASS] [private]

Definition at line 310 of file vegetable_manager.h.

CVector NL3D::CVegetableManager::_ViewCenter [private]

Definition at line 379 of file vegetable_manager.h. Referenced by render(), and setupVertexProgramConstants().

double NL3D::CVegetableManager::_WindAnimTime [private]

Definition at line 363 of file vegetable_manager.h. Referenced by CVegetableManager(), render(), and setupVertexProgramConstants().

float NL3D::CVegetableManager::_WindBendMin [private]

Definition at line 358 of file vegetable_manager.h. Referenced by CVegetableManager(), render(), setupVertexProgramConstants(), and setWind().

NLMISC::CVector2f NL3D::CVegetableManager::_WindDeltaTable[NL3D_VEGETABLE_VP_LUT_SIZE] [private]

Definition at line 369 of file vegetable_manager.h. Referenced by render(), and setupVertexProgramConstants().

CVector NL3D::CVegetableManager::_WindDirection [private]

Definition at line 355 of file vegetable_manager.h. Referenced by CVegetableManager(), render(), and setWind().

float NL3D::CVegetableManager::_WindFrequency [private]

Definition at line 356 of file vegetable_manager.h. Referenced by CVegetableManager(), render(), and setWind().

float NL3D::CVegetableManager::_WindPower [private]

Definition at line 357 of file vegetable_manager.h. Referenced by CVegetableManager(), render(), setupVertexProgramConstants(), and setWind().

double NL3D::CVegetableManager::_WindPrecRenderTime [private]

Definition at line 361 of file vegetable_manager.h. Referenced by CVegetableManager(), and render().

NLMISC::CVector2f NL3D::CVegetableManager::_WindTable[NL3D_VEGETABLE_VP_LUT_SIZE] [private]

Definition at line 368 of file vegetable_manager.h. Referenced by render(), and setupVertexProgramConstants().

float NL3D::CVegetableManager::_ZSortLayerDistMax [private]

Definition at line 393 of file vegetable_manager.h. Referenced by render().

std::vector<CVegetableBlendLayerModel*> NL3D::CVegetableManager::_ZSortModelLayers [private]

Definition at line 395 of file vegetable_manager.h. Referenced by createVegetableBlendLayersModels(), CVegetableManager(), render(), and ~CVegetableManager().

std::vector<CVegetableBlendLayerModel*> NL3D::CVegetableManager::_ZSortModelLayersUW [private]

Definition at line 397 of file vegetable_manager.h. Referenced by createVegetableBlendLayersModels(), CVegetableManager(), render(), and ~CVegetableManager().

CScene* NL3D::CVegetableManager::_ZSortScene [private]

Definition at line 394 of file vegetable_manager.h. Referenced by createVegetableBlendLayersModels(), and ~CVegetableManager().

---

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

• vegetable_manager.h
• vegetable_manager.cpp

---