aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-11-15 20:23:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/3d/landscape.cpp

3953 lines
122 KiB
C++
Raw Normal View History

initial version
2010-05-06 00:08:41 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "std3d.h"
#include "nel/3d/landscape.h"
#include "nel/3d/landscape_model.h"
#include "nel/misc/bsphere.h"
#include "nel/3d/texture_file.h"
#include "nel/3d/texture_far.h"
#include "nel/3d/landscape_profile.h"
#include "nel/3d/height_map.h"
#include "nel/3d/tile_noise_map.h"
#include "nel/3d/vegetable_manager.h"
#include "nel/3d/vegetable.h"
#include "nel/3d/landscape_vegetable_block.h"
#include "nel/misc/fast_floor.h"
#include "nel/3d/tile_vegetable_desc.h"
#include "nel/3d/texture_dlm.h"
#include "nel/3d/patchdlm_context.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/3d/scene.h"
#include "nel/3d/vertex_program.h"
using namespace NLMISC;
using namespace std;
namespace NL3D
{
// ***************************************************************************
/*
Target is 20K faces in frustum.
So 80K faces at same time
So 160K elements (bin tree).
A good BlockSize (in my opinion) is EstimatedMaxSize / 10, to have less memory leak as possible,
and to make not so many system allocation.
NL3D_TESSRDR_ALLOC_BLOCKSIZE is 2 times less, because elements are in Far zone or in Near zone only
(approx same size...)
*/
#define NL3D_TESS_ALLOC_BLOCKSIZE 16000
#define NL3D_TESSRDR_ALLOC_BLOCKSIZE 8000
// ***************************************************************************
// This value is important for the precision of the priority list
#define NL3D_REFINE_PLIST_DIST_STEP 0.0625
/* This value is important, because faces will be inserted at maximum at this entry in the priority list.
If not so big (eg 50 meters), a big bunch of faces may be inserted in this entry, which may cause slow down
sometimes, when all this bunch comes to 0 in the priority list.
To avoid such a thing, see CTessFacePriorityList::init(), and use of NL3D_REFINE_PLIST_DIST_MAX_MOD.
Here, distMax= 2048*0.0625= 128
*/
#define NL3D_REFINE_PLIST_NUM_ENTRIES 2048
#define NL3D_REFINE_PLIST_DIST_MAX_MOD 0.7f
// For the Split priority list only, numbers of quadrants. MergeList has 0 quadrants.
#define NL3D_REFINE_PLIST_SPLIT_NUMQUADRANT 16
/*
OverHead size of one RollingTable of priority list is 8 * (NL3D_REFINE_PLIST_NUM_ENTRIES)
So here, it is "only" 16K.
Since we have 2 Priority list and 16 quadrants for the split one, the total overhead is 18*12.8= 288K
*/
// ***************************************************************************
// Size (in cases) of the quadgrid. must be e power of 2.
const uint CLandscape::_PatchQuadGridSize= 128;
// Size of a case of the quadgrid.
const float CLandscape::_PatchQuadGridEltSize= 16;
// ***************************************************************************
// Bitmap Cross
class CTextureCross : public ITexture
{
public:
/**
* Generate the texture
* \author Stephane Coutelas
* \date 2000
*/
virtual void doGenerate(bool /* async */)
{
// Resize
resize (16, 16);
// Cross
static const uint32 cross[16*16]=
{
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
};
// Null
memcpy (&_Data[0][0], cross, 16*16*4);
}
// Dummy serial...
virtual void serial(NLMISC::IStream &/* f */) throw(NLMISC::EStream) {nlstop;}
NLMISC_DECLARE_CLASS(CTextureCross);
};
// ***************************************************************************
const char *EBadBind::what() const throw()
{
sint numErr= 0;
const sint NErrByLines= 4;
_Output= "Landscape Bind Error in (3DSMax indices!! (+1) ): ";
std::list<CBindError>::const_iterator it;
for(it= BindErrors.begin();it!=BindErrors.end(); it++, numErr++)
{
char tmp[256];
sint x= it->ZoneId & 255;
sint y= it->ZoneId >> 8;
sprintf(tmp, "zone%3d_%c%c.patch%3d; ", y+1, (char)('A'+(x/26)), (char)('A'+(x%26)), it->PatchId+1);
if( (numErr%NErrByLines) == 0)
_Output+= "\n";
_Output+= tmp;
}
return _Output.c_str();
}
// ***************************************************************************
// Init BlockAllcoator with standard BlockMemory.
CLandscape::CLandscape() :
TessFaceAllocator(NL3D_TESS_ALLOC_BLOCKSIZE),
TessVertexAllocator(NL3D_TESS_ALLOC_BLOCKSIZE),
TessNearVertexAllocator(NL3D_TESSRDR_ALLOC_BLOCKSIZE),
TessFarVertexAllocator(NL3D_TESSRDR_ALLOC_BLOCKSIZE),
TileMaterialAllocator(NL3D_TESSRDR_ALLOC_BLOCKSIZE),
TileFaceAllocator(NL3D_TESSRDR_ALLOC_BLOCKSIZE),
_Far0VB(CLandscapeVBAllocator::Far0, "LandscapeFar0VB"),
_Far1VB(CLandscapeVBAllocator::Far1, "LandscapeFar1VB"),
_TileVB(CLandscapeVBAllocator::Tile, "LandscapeTileVB")
{
OwnerModel = NULL;
// Init the Tile Infos with Max TileId
TileInfos.resize(NL3D::NbTilesMax, NULL);
// Far texture not initialized till initTileBanks is not called
_FarInitialized=false;
// Init far lighting with White/black
setupStaticLight (CRGBA(255,255,255), CRGBA(0,0,0), 1.f);
// Default material for pointLights
_PointLightDiffuseMaterial= CRGBA::White;
_FarTransition= 10; // 10 meters.
_TileDistNear=100.f;
_Threshold= 0.001f;
_RefineMode=true;
_TileMaxSubdivision= 0;
_NFreeLightMaps= 0;
// By default Automatic light comes from up.
_AutomaticLighting = false;
_AutomaticLightDir= -CVector::K;
// By default, noise is enabled.
_NoiseEnabled= true;
// By default, we compute Geomorph and Alpha in software.
_VertexShaderOk= false;
_VPThresholdChange= false;
_RenderMustRefillVB= false;
// priority list.
_MustRefineAllAtNextRefine= true;
_SplitPriorityList.init(NL3D_REFINE_PLIST_DIST_STEP, NL3D_REFINE_PLIST_NUM_ENTRIES, NL3D_REFINE_PLIST_DIST_MAX_MOD, NL3D_REFINE_PLIST_SPLIT_NUMQUADRANT);
// See updateRefine* Doc in tesselation.cpp for why the merge list do not need quadrants.
_MergePriorityList.init(NL3D_REFINE_PLIST_DIST_STEP, NL3D_REFINE_PLIST_NUM_ENTRIES, NL3D_REFINE_PLIST_DIST_MAX_MOD, 0);
// just for getTesselatedPos to work properly.
_OldRefineCenter= CVector::Null;
// create / Init the vegetable manager.
_VegetableManager= new CVegetableManager(NL3D_LANDSCAPE_VEGETABLE_MAX_AGP_VERTEX_UNLIT, NL3D_LANDSCAPE_VEGETABLE_MAX_AGP_VERTEX_LIGHTED);
// Init vegetable setup.
_VegetableManagerEnabled= false;
_DriverOkForVegetable= false;
// default global vegetable color, used for dynamic lighting only (arbitrary).
_DLMGlobalVegetableColor.set(180, 180, 180);
_PZBModelPosition= CVector::Null;
// Default: no updateLighting.
_ULFrequency= 0;
_ULPrecTimeInit= false;
// Default: no textureFar created.
_ULTotalFarPixels= 0;
_ULFarPixelsToUpdate= 0;
_ULRootTextureFar= NULL;
// Default: no patch created
_ULTotalNearPixels= 0;
_ULNearPixelsToUpdate= 0;
_ULRootNearPatch= NULL;
_ULNearCurrentTessBlockId= 0;
// Dynamic Lighting.
_TextureDLM= new CTextureDLM(NL3D_LANDSCAPE_DLM_WIDTH, NL3D_LANDSCAPE_DLM_HEIGHT);
_PatchDLMContextList= new CPatchDLMContextList;
_DLMMaxAttEnd= 30.f;
CLandscapeGlobals::PassTriArray.setFormat(NL_LANDSCAPE_INDEX_FORMAT);
// Alloc some global space for tri rendering.
if( CLandscapeGlobals::PassTriArray.getNumIndexes() < 1000 )
CLandscapeGlobals::PassTriArray.setNumIndexes( 1000 );
// set volatile index buffer to avoid stalls
CLandscapeGlobals::PassTriArray.setPreferredMemory(CIndexBuffer::RAMVolatile, false);
_LockCount = 0;
_TextureTileCategory= new ITexture::CTextureCategory("LANDSCAPE TILES");
_TextureFarCategory= new ITexture::CTextureCategory("LANDSCAPE FAR");
_TextureNearCategory= new ITexture::CTextureCategory("LANDSCAPE LIGHTMAP NEAR");
}
// ***************************************************************************
CLandscape::~CLandscape()
{
clear();
// release the VegetableManager.
delete _VegetableManager;
_VegetableManager= NULL;
// Dynamic Lighting.
// smartPtr delete
_TextureDLM= NULL;
delete _PatchDLMContextList;
_PatchDLMContextList= NULL;
}
// ***************************************************************************
void CLandscape::init()
{
// Fill Far mat.
// Must init his BlendFunction here!!! becaus it switch between blend on/off during rendering.
FarMaterial.initUnlit();
FarMaterial.setSrcBlend(CMaterial::srcalpha);
FarMaterial.setDstBlend(CMaterial::invsrcalpha);
// FarMaterial: pass trhough Alpha from diffuse.
FarMaterial.texEnvOpAlpha(0, CMaterial::Replace);
FarMaterial.texEnvArg0Alpha(0, CMaterial::Diffuse, CMaterial::SrcAlpha);
FarMaterial.texEnvOpAlpha(1, CMaterial::Replace);
FarMaterial.texEnvArg0Alpha(1, CMaterial::Diffuse, CMaterial::SrcAlpha);
// FarMaterial: Add RGB from static lightmap and dynamic lightmap
FarMaterial.texEnvOpRGB(0, CMaterial::Replace);
FarMaterial.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
FarMaterial.texEnvOpRGB(1, CMaterial::Add);
FarMaterial.texEnvArg0RGB(1, CMaterial::Texture, CMaterial::SrcColor);
FarMaterial.texEnvArg1RGB(1, CMaterial::Previous, CMaterial::SrcColor);
// Init material for tile.
TileMaterial.initUnlit();
// init quadGrid.
_PatchQuadGrid.create(_PatchQuadGridSize, _PatchQuadGridEltSize);
}
// ***************************************************************************
void CLandscape::setThreshold (float thre)
{
thre= max(thre, 0.f);
if(thre != _Threshold)
{
_Threshold= thre;
_VPThresholdChange= true;
// force refine all at next refine
_MustRefineAllAtNextRefine= true;
}
}
// ***************************************************************************
void CLandscape::setTileNear (float tileNear)
{
tileNear= max(tileNear, _FarTransition);
if(tileNear!=_TileDistNear)
{
_TileDistNear= tileNear;
resetRenderFarAndDeleteVBFV();
// force refine all at next refine
_MustRefineAllAtNextRefine= true;
}
}
// ***************************************************************************
void CLandscape::setTileMaxSubdivision (uint tileDiv)
{
nlassert(tileDiv<=4);
if(tileDiv!=_TileMaxSubdivision)
{
_TileMaxSubdivision= tileDiv;
// Force at Tile==0. Nex refine will split correctly.
forceMergeAtTileLevel();
}
}
// ***************************************************************************
uint CLandscape::getTileMaxSubdivision ()
{
return _TileMaxSubdivision;
}
// ***************************************************************************
void CLandscape::resetRenderFarAndDeleteVBFV()
{
// For all patch of all zones.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
((*it).second)->resetRenderFarAndDeleteVBFV();
}
}
// ***************************************************************************
void CLandscape::forceMergeAtTileLevel()
{
// For all patch of all zones.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
((*it).second)->forceMergeAtTileLevel();
}
}
// ***************************************************************************
bool CLandscape::addZone(const CZone &newZone)
{
// -1. Update globals
updateGlobalsAndLockBuffers (CVector::Null);
// NB: adding a zone may add vertices in VB in visible patchs (because of binds)=> buffers are locked.
uint16 zoneId= newZone.getZoneId();
if(Zones.find(zoneId)!=Zones.end())
{
unlockBuffers();
return false;
}
CZone *zone= new CZone;
// copy zone.
zone->build(newZone);
// Affect the current lighting of pointLight to the zone.
if (OwnerModel)
{
CScene *scene = OwnerModel->getOwnerScene();
zone->_PointLightArray.initAnimatedLightIndex(*scene);
zone->_PointLightArray.setPointLightFactor(*scene);
}
// apply the landscape heightField, modifying BBoxes.
zone->applyHeightField(*this);
// compile the zone for this landscape.
zone->compile(this, Zones);
// For test of _PatchQuadGrid erase.
CAABBox zoneBBForErase= zone->getZoneBB().getAABBox();
// Avoid precision problems by enlarging a little bbox size of zone for erase
zoneBBForErase.setHalfSize( zoneBBForErase.getHalfSize() * 1.1f);
// add patchs of this zone to the quadgrid.
for(sint i= 0; i<zone->getNumPatchs(); i++)
{
const CPatch *pa= ((const CZone*)zone)->getPatch(i);
CPatchIdentEx paId;
paId.ZoneId= zoneId;
paId.PatchId= uint16(i);
paId.Patch= pa;
CAABBox bb= pa->buildBBox();
_PatchQuadGrid.insert(bb.getMin(), bb.getMax(), paId);
// NB: the bbox of zone is used to remove patch. Hence it is VERY important that zoneBBox includes
// all patchs bbox (else some patchs entries may not be deleted in removeZone()).
nlassert(zoneBBForErase.include(bb));
}
// Must realase VB Buffers
unlockBuffers();
// Because bind may add faces in other (visible) zones because of enforced split, we must check
// and update any FaceVector.
updateTessBlocksFaceVector();
return true;
}
// ***************************************************************************
bool CLandscape::removeZone(uint16 zoneId)
{
// -1. Update globals
updateGlobalsAndLockBuffers (CVector::Null);
// NB: remove a zone may change vertices in VB in visible patchs => buffers are locked.
// find the zone.
if(Zones.find(zoneId)==Zones.end())
{
unlockBuffers();
return false;
}
CZone *zone= Zones[zoneId];
// delete patchs from this zone to the quadgrid.
// use the quadgrid itself to find where patch are. do this using bbox of zone.
CAABBox zoneBBForErase= zone->getZoneBB().getAABBox();
// Avoid precision problems by enlarging a little bbox size of zone for erase
zoneBBForErase.setHalfSize( zoneBBForErase.getHalfSize() * 1.1f);
// select iterators in the area of this zone.
_PatchQuadGrid.clearSelection();
_PatchQuadGrid.select(zoneBBForErase.getMin(), zoneBBForErase.getMax());
// for each patch, remove it if from deleted zone.
CQuadGrid<CPatchIdentEx>::CIterator it;
sint nPatchRemoved= 0;
for(it= _PatchQuadGrid.begin(); it!= _PatchQuadGrid.end();)
{
// if the patch belong to the zone to remove
if( (*it).ZoneId== zone->getZoneId() )
{
// remove from the quadgrid.
it= _PatchQuadGrid.erase(it);
nPatchRemoved++;
}
else
it++;
}
// verify we have removed all patch in the quadGrid for this zone
nlassert(nPatchRemoved==zone->getNumPatchs());
// remove the zone.
zone->release(Zones);
delete zone;
// Must realase VB Buffers
unlockBuffers();
// because of forceMerge() at unbind, removeZone() can cause change in faces in other (visible) zones.
updateTessBlocksFaceVector();
return true;
}
// ***************************************************************************
void CLandscape::getZoneList(std::vector<uint16> &zoneIds) const
{
zoneIds.clear();
zoneIds.reserve(Zones.size());
std::map<uint16, CZone*>::const_iterator it;
for(it= Zones.begin();it!=Zones.end();it++)
{
zoneIds.push_back((*it).first);
}
}
// ***************************************************************************
void CLandscape::buildZoneName(sint zoneId, std::string &zoneName)
{
char tmp[256];
sint x= zoneId & 255;
sint y= zoneId >> 8;
sprintf(tmp, "%d_%c%c", y+1, (char)('A'+(x/26)), (char)('A'+(x%26)));
zoneName= tmp;
}
// ***************************************************************************
void CLandscape::clear()
{
// Build the list of zoneId.
vector<uint16> zoneIds;
getZoneList(zoneIds);
// Remove each zone one by one.
sint i;
for(i=0;i<(sint)zoneIds.size();i++)
{
nlverify(removeZone(zoneIds[i]));
}
// ensure the quadgrid is empty.
_PatchQuadGrid.clear();
releaseAllTiles();
// If not done, delete all VBhards allocated.
_Far0VB.clear();
_Far1VB.clear();
_TileVB.clear();
// Reset All Far Texture and unlink _ULRootTextureFar ciruclarList.
ItSPRenderPassVector itFar= _TextureFars.begin();
// unitl set is empty
while( itFar != _TextureFars.end() )
{
// erase with link update.
clearFarRenderPass(*itFar);
itFar++;
}
// delete all
_TextureFars.clear();
// reset driver.
_Driver= NULL;
}
// ***************************************************************************
void CLandscape::setDriver(IDriver *drv)
{
nlassert(drv);
if(_Driver != drv)
{
_Driver= drv;
// Does the driver support VertexShader???
// only if VP supported by GPU.
_VertexShaderOk= (_Driver->isVertexProgramSupported() && !_Driver->isVertexProgramEmulated());
// Does the driver has sufficient requirements for Vegetable???
// only if VP supported by GPU, and Only if max vertices allowed.
_DriverOkForVegetable= _VertexShaderOk && (_Driver->getMaxVerticesByVertexBufferHard()>=(uint)NL3D_LANDSCAPE_VEGETABLE_MAX_AGP_VERTEX_MAX);
}
}
// ***************************************************************************
void CLandscape::clip(const CVector &refineCenter, const std::vector<CPlane> &pyramid)
{
// -1. Update globals
updateGlobalsAndLockBuffers (refineCenter);
// NB: clip may add/remove vertices in VB in visible patchs => buffers are locked.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
(*it).second->clip(pyramid);
}
// Must realase VB Buffers
unlockBuffers();
// clip() should not cause change in faces in visible patchs.
// It should not happens, but check for security.
nlassert(_TessBlockModificationRoot.getNextToModify()==NULL);
updateTessBlocksFaceVector();
}
// ***************************************************************************
void CLandscape::refine(const CVector &refineCenter)
{
NL3D_PROFILE_LAND_SET(ProfNRefineFaces, 0);
NL3D_PROFILE_LAND_SET(ProfNRefineComputeFaces, 0);
NL3D_PROFILE_LAND_SET(ProfNRefineLeaves, 0);
NL3D_PROFILE_LAND_SET(ProfNSplits, 0);
NL3D_PROFILE_LAND_SET(ProfNMerges, 0);
NL3D_PROFILE_LAND_SET(ProfNRefineInTileTransition, 0);
NL3D_PROFILE_LAND_SET(ProfNRefineWithLowDistance, 0);
NL3D_PROFILE_LAND_SET(ProfNSplitsPass, 0);
if(!_RefineMode)
return;
// Update the priority list.
// ==========================
CTessFacePListNode rootSplitTessFaceToUpdate;
CTessFacePListNode rootMergeTessFaceToUpdate;
if( _MustRefineAllAtNextRefine )
{
// ok, first pass done, setup OldRefineCetner
_MustRefineAllAtNextRefine= false;
_OldRefineCenter= refineCenter;
// then shift all faces
_SplitPriorityList.shiftAll(rootSplitTessFaceToUpdate);
_MergePriorityList.shiftAll(rootMergeTessFaceToUpdate);
}
else
{
// else, compute delta between positions
CVector diff= refineCenter - _OldRefineCenter;
_OldRefineCenter= refineCenter;
// and shift according to distance of deplacement.
_SplitPriorityList.shift(diff, rootSplitTessFaceToUpdate);
_MergePriorityList.shift(diff, rootMergeTessFaceToUpdate);
}
// Refine Faces which may need it.
// ==========================
// Update globals
updateGlobalsAndLockBuffers (refineCenter);
// NB: refine may change vertices in VB in visible patchs => buffers are locked.
// Increment the update date.
CLandscapeGlobals::CurrentDate++;
// Because CTessFacePriorityList::insert use it.
NLMISC::OptFastFloorBegin();
/* While there is still face in list, update them
NB: updateRefine() always insert the face in _***PriorityList, so face is removed from
root***TessFaceToUpdate list.
NB: it is possible ( with enforced merge() ) that faces dissapears from root***TessFaceToUpdate list
before they are traversed here. It is why we must use a Circular list system, and not an array of elements.
Basically. TessFaces are ALWAYS in a list, either in one of the entry list in _***PriorityList, or in
root***TessFaceToUpdate list.
It is newTessFace() and deleteTessFace() which insert/remove the nodes in the list.
*/
// Update the Merge priority list.
while( rootMergeTessFaceToUpdate.nextInPList() != &rootMergeTessFaceToUpdate )
{
// Get the face.
CTessFace *face= static_cast<CTessFace*>(rootMergeTessFaceToUpdate.nextInPList());
// update the refine of this face. This may lead in deletion (merge) of other faces which are still in
// root***TessFaceToUpdate, but it's work.
face->updateRefineMerge();
}
// Update the Split priority list.
do
{
NL3D_PROFILE_LAND_ADD(ProfNSplitsPass, 1);
// Append the new leaves, to the list of triangles to update
rootSplitTessFaceToUpdate.appendPList(_RootNewLeaves);
// While triangle to test for split exists
while( rootSplitTessFaceToUpdate.nextInPList() != &rootSplitTessFaceToUpdate )
{
// Get the face.
CTessFace *face= static_cast<CTessFace*>(rootSplitTessFaceToUpdate.nextInPList());
// update the refine of this face.
face->updateRefineSplit();
}
}
// do it until we are sure no more split is needed, ie no more faces are created
while( _RootNewLeaves.nextInPList() != &_RootNewLeaves );
// Because CTessFacePriorityList::insert use it.
NLMISC::OptFastFloorEnd();
// Before unlockBuffers, test for vegetable IG creation.
{
H_AUTO( NL3D_Vegetable_Update );
// Because CLandscapeVegetableBlock::update() use OptFastFloor..
NLMISC::OptFastFloorBegin();
// For each vegetableBlock, test IG creation
CLandscapeVegetableBlock *vegetBlock= _VegetableBlockList.begin();
for(;vegetBlock!=NULL; vegetBlock= (CLandscapeVegetableBlock*)vegetBlock->Next)
{
vegetBlock->update(refineCenter, _VegetableManager);
}
// update lighting for vegetables
_VegetableManager->updateLighting();
// Stop fastFloor optim.
NLMISC::OptFastFloorEnd();
}
// Must realase VB Buffers
unlockBuffers();
// refine() may cause change in faces in visible patchs.
updateTessBlocksFaceVector();
}
// ***************************************************************************
void CLandscape::refineAll(const CVector &refineCenter)
{
// -1. Update globals
updateGlobalsAndLockBuffers (refineCenter);
// NB: refineAll may change vertices in VB in visible patchs => buffers are locked.
// Increment the update date.
CLandscapeGlobals::CurrentDate++;
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
(*it).second->refineAll();
}
// Must realase VB Buffers
unlockBuffers();
// refineAll() may cause change in faces in visible patchs.
updateTessBlocksFaceVector();
}
// ***************************************************************************
void CLandscape::excludePatchFromRefineAll(sint zoneId, uint patch, bool exclude)
{
ItZoneMap it= Zones.find(uint16(zoneId));
if(it!=Zones.end())
{
it->second->excludePatchFromRefineAll(patch, exclude);
}
}
// ***************************************************************************
void CLandscape::averageTesselationVertices()
{
// -1. Update globals
updateGlobalsAndLockBuffers (CVector::Null);
// NB: averageTesselationVertices may change vertices in VB in visible patchs => buffers are locked.
// Increment the update date.
CLandscapeGlobals::CurrentDate++;
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
(*it).second->averageTesselationVertices();
}
// Must realase VB Buffers
unlockBuffers();
// averageTesselationVertices() should not cause change in faces in any patchs.
// It should not happens, but check for security.
nlassert(_TessBlockModificationRoot.getNextToModify()==NULL);
updateTessBlocksFaceVector();
}
// ***************************************************************************
void CLandscape::updateGlobalsAndLockBuffers (const CVector &refineCenter)
{
// Setup CLandscapeGlobals static members...
// Far limits.
CLandscapeGlobals::FarTransition= _FarTransition;
// Tile subdivsion part.
CLandscapeGlobals::TileMaxSubdivision= _TileMaxSubdivision;
CLandscapeGlobals::TileDistNear = _TileDistNear;
CLandscapeGlobals::TileDistFar = CLandscapeGlobals::TileDistNear+20;
CLandscapeGlobals::TileDistNearSqr = sqr(CLandscapeGlobals::TileDistNear);
CLandscapeGlobals::TileDistFarSqr = sqr(CLandscapeGlobals::TileDistFar);
CLandscapeGlobals::OOTileDistDeltaSqr = 1.0f / (CLandscapeGlobals::TileDistFarSqr - CLandscapeGlobals::TileDistNearSqr);
// Tile Pixel size part.
// \todo yoyo: choose according to wanted tile pixel size.
CLandscapeGlobals::TilePixelSize= 128.0f;
CLandscapeGlobals::TilePixelBias128= 0.5f/CLandscapeGlobals::TilePixelSize;
CLandscapeGlobals::TilePixelScale128= 1-1/CLandscapeGlobals::TilePixelSize;
CLandscapeGlobals::TilePixelBias256= 0.5f/(CLandscapeGlobals::TilePixelSize*2);
CLandscapeGlobals::TilePixelScale256= 1-1/(CLandscapeGlobals::TilePixelSize*2);
// RefineThreshold.
CLandscapeGlobals::RefineThreshold= _Threshold;
if (_Threshold == 0.0f)
CLandscapeGlobals::OORefineThreshold = FLT_MAX;
else
CLandscapeGlobals::OORefineThreshold = 1.0f / CLandscapeGlobals::RefineThreshold;
// Refine Center*.
CLandscapeGlobals::RefineCenter= refineCenter;
CLandscapeGlobals::TileFarSphere.Center= CLandscapeGlobals::RefineCenter;
CLandscapeGlobals::TileFarSphere.Radius= CLandscapeGlobals::TileDistFar;
CLandscapeGlobals::TileNearSphere.Center= CLandscapeGlobals::RefineCenter;
CLandscapeGlobals::TileNearSphere.Radius= CLandscapeGlobals::TileDistNear;
// PZBModelPosition
CLandscapeGlobals::PZBModelPosition= _PZBModelPosition;
// VB Allocators.
CLandscapeGlobals::CurrentFar0VBAllocator= &_Far0VB;
CLandscapeGlobals::CurrentFar1VBAllocator= &_Far1VB;
CLandscapeGlobals::CurrentTileVBAllocator= &_TileVB;
if(_Driver)
lockBuffers ();
}
// ***************************************************************************
void CLandscape::lockBuffers ()
{
// Already locked
if ((_LockCount++) == 0)
{
// Must check driver, and create VB infos,locking buffers.
if(_Driver)
{
_Far0VB.updateDriver(_Driver);
_Far1VB.updateDriver(_Driver);
_TileVB.updateDriver(_Driver);
// must do the same for _VegetableManager.
if(_DriverOkForVegetable)
_VegetableManager->updateDriver(_Driver);
}
_Far0VB.lockBuffer(CLandscapeGlobals::CurrentFar0VBInfo);
_Far1VB.lockBuffer(CLandscapeGlobals::CurrentFar1VBInfo);
_TileVB.lockBuffer(CLandscapeGlobals::CurrentTileVBInfo);
// lock buffer of the vegetable manager.
_VegetableManager->lockBuffers();
// VertexProgrma mode???
CLandscapeGlobals::VertexProgramEnabled= _VertexShaderOk;
}
}
// ***************************************************************************
void CLandscape::unlockBuffers(bool force)
{
// Already locked
if ((_LockCount == 1) || force)
{
_Far0VB.unlockBuffer();
_Far1VB.unlockBuffer();
_TileVB.unlockBuffer();
// unlock buffer of the vegetable manager.
_VegetableManager->unlockBuffers();
_LockCount = 0;
}
if (_LockCount > 0)
_LockCount--;
}
// ***************************************************************************
void CLandscape::updateTessBlocksFaceVector()
{
// while some tessBlock to update remains.
CTessBlock *tb;
while( (tb=_TessBlockModificationRoot.getNextToModify()) !=NULL )
{
// Get the patch which owns this TessBlock.
CPatch *patch= tb->getPatch();
// If this patch is visible, recreate faceVector for his tessBlock.
patch->recreateTessBlockFaceVector(*tb);
// remove from list.
tb->removeFromModifyList();
}
}
// ***************************************************************************
static inline void initPassTriArray(CPatchRdrPass &/* pass */, uint32 numIndex)
{
//uint numIndices= pass.getMaxRenderedFaces()*3;
// realloc if necessary
// We use
/*if( CLandscapeGlobals::PassTriArray.getNumIndexes() < numIndices )
CLandscapeGlobals::PassTriArray.setNumIndexes( numIndices );*/
CLandscapeGlobals::PassTriArray.setFormat(NL_LANDSCAPE_INDEX_FORMAT);
CLandscapeGlobals::PassTriArray.setNumIndexes(numIndex);
// reset ptr.
nlassert (!CLandscapeGlobals::PassTriArray.isLocked());
CLandscapeGlobals::PassTriArray.lock (CLandscapeGlobals::PassTriArrayIBA);
NL3D_LandscapeGlobals_PassTriCurPtr= CLandscapeGlobals::PassTriArrayIBA.getPtr();
NL3D_LandscapeGlobals_PassTriFormat = CLandscapeGlobals::PassTriArrayIBA.getFormat();
}
// ***************************************************************************
static
#ifndef NL_DEBUG
inline
#endif
void drawPassTriArray(CMaterial &mat)
{
nlassert (CLandscapeGlobals::PassTriArray.isLocked());
CLandscapeGlobals::PassTriArrayIBA.unlock();
if(NL3D_LandscapeGlobals_PassNTri>0)
{
//mat.setZFunc(CMaterial::ZFunc::greaterequal);
CLandscapeGlobals::PatchCurrentDriver->setupMaterial(mat);
CLandscapeGlobals::PatchCurrentDriver->activeIndexBuffer(CLandscapeGlobals::PassTriArray);
CLandscapeGlobals::PatchCurrentDriver->renderSimpleTriangles(0, NL3D_LandscapeGlobals_PassNTri);
NL3D_LandscapeGlobals_PassNTri= 0;
}
}
// ***************************************************************************
static inline uint32 countNumWantedIndex(CRdrTileId *tileToRdr, uint rdrPass)
{
uint32 numIndex = 0;
while(tileToRdr)
{
if(tileToRdr->TileMaterial->Pass[rdrPass].PatchRdrPass)
{
// renderSimpleTriangles() with the material setuped.
numIndex += *(tileToRdr->TileMaterial->TileFaceVectors[rdrPass]);
}
tileToRdr= (CRdrTileId*)tileToRdr->getNext();
}
return 3 * numIndex;
}
// ***************************************************************************
static inline uint32 countNumWantedIndexFar0(CPatch *patch)
{
uint32 numTri = 0;
while(patch)
{
// renderSimpleTriangles() with the material setuped.
numTri += patch->countNumTriFar0();
patch = patch->getNextFar0ToRdr();
}
return 3 * numTri;
}
// ***************************************************************************
static inline uint32 countNumWantedIndexFar1(CPatch *patch)
{
uint32 numTri = 0;
while(patch)
{
numTri += patch->countNumTriFar1();
patch = patch ->getNextFar1ToRdr();
}
return 3 * numTri;
}
// ***************************************************************************
void CLandscape::render(const CVector &refineCenter, const CVector &frontVector, const CPlane pyramid[NL3D_TESSBLOCK_NUM_CLIP_PLANE], bool doTileAddPass)
{
IDriver *driver= _Driver;
nlassert(driver);
// values in Stencil Buffer which match with landscape are replace by 128
// rest of Stencil is replace by 0.
CScene *scene = NULL;
if (OwnerModel)
{
scene = OwnerModel->getOwnerScene();
if(scene->getLandscapePolyDrawingCallback())
{
scene->getLandscapePolyDrawingCallback()->beginPolyDrawing();
}
}
// Increment the update date for preRender.
CLandscapeGlobals::CurrentRenderDate++;
ItZoneMap it;
sint i;
ItTileRdrPassSet itTile;
ItSPRenderPassVector itFar;
// Yoyo: profile.
NL3D_PROFILE_LAND_SET(ProfNRdrFar0, 0);
NL3D_PROFILE_LAND_SET(ProfNRdrFar1, 0);
NL3D_PROFILE_LAND_SET(ProfNPatchRdrFar0, 0);
NL3D_PROFILE_LAND_SET(ProfNPatchRdrFar1, 0);
for(i=0;i<NL3D_MAX_TILE_PASS;i++)
{
NL3D_PROFILE_LAND_SET(ProfNRdrTile[i], 0);
}
// -2. Update globals
//====================
updateGlobalsAndLockBuffers (refineCenter);
// NB: render may change vertices in VB in visible patchs => buffers are locked.
// -1. clear all PatchRenderPass renderList
//===================
H_BEFORE( NL3D_Landscape_Render_Clear );
// Fars.
for(itFar= _TextureFars.begin(); itFar!= _TextureFars.end(); itFar++)
{
CPatchRdrPass &pass= **itFar;
// clear list.
pass.clearAllRenderList();
}
// Tiles.
for(itTile= TileRdrPassSet.begin(); itTile!= TileRdrPassSet.end(); itTile++)
{
CPatchRdrPass &pass= const_cast<CPatchRdrPass&>(*itTile);
// clear list.
pass.clearAllRenderList();
}
// Lightmaps.
for(sint lightRdrPass=0; lightRdrPass<(sint)_TextureNears.size(); lightRdrPass++)
{
CPatchRdrPass &pass= *_TextureNears[lightRdrPass];
// clear list.
pass.clearAllRenderList();
}
H_AFTER( NL3D_Landscape_Render_Clear );
// 0. preRender pass.
//===================
H_BEFORE( NL3D_Landscape_Render_PreRender );
// change Far0 / Far1.
// Clip TessBlocks against pyramid and Far Limit.
for(i=0; i<NL3D_TESSBLOCK_NUM_CLIP_PLANE; i++)
{
CTessBlock::CurrentPyramid[i]= pyramid[i];
}
// Update VB with change of Far0 / Far1.
for(it= Zones.begin();it!=Zones.end();it++)
{
(*it).second->preRender();
}
H_AFTER( NL3D_Landscape_Render_PreRender );
H_BEFORE( NL3D_Landscape_Render_Refill );
// Check if the vertex buffers must be refilled
_Far0VB.checkVertexBuffersResident();
_Far1VB.checkVertexBuffersResident();
_TileVB.checkVertexBuffersResident();
// Reallocation Mgt. If any of the VB is reallocated, we must refill it entirely.
// NB: all VBs are refilled entirely. It is not optimal (maybe 3* too slow), but reallocation are supposed
// to be very rare.
if( _Far0VB.reallocationOccurs() || _Far1VB.reallocationOccurs() || _TileVB.reallocationOccurs() )
_RenderMustRefillVB= true;
// VertexProgram dependency on RefineThreshold Management. If VertexShader, and if the refineThreshold has
// changed since the last time, we must refill All the VB, because data are out of date.
if( _VertexShaderOk && _VPThresholdChange )
{
_VPThresholdChange= false;
_RenderMustRefillVB= true;
}
// If we must refill the VB (for any reason).
if(_RenderMustRefillVB )
{
// Ok, ok, we refill All the VB with good data.
_RenderMustRefillVB= false;
// First reset the flag, so fillVB() will effectively fill the VB.
_Far0VB.resetReallocation();
_Far1VB.resetReallocation();
_TileVB.resetReallocation();
// Then recompute good VBInfo (those in CurrentVBInfo are false!!).
// Do it by unlocking then re-locking Buffers.
unlockBuffers(true);
lockBuffers();
// Finally, fill the VB for all patchs visible.
for(it= Zones.begin();it!=Zones.end();it++)
{
if((*it).second->ClipResult==CZone::ClipOut)
continue;
for(sint i=0;i<(*it).second->getNumPatchs(); i++)
{
CPatch *patch= (*it).second->getPatch(i);
patch->fillVBIfVisible();
}
}
}
H_AFTER( NL3D_Landscape_Render_Refill );
H_BEFORE( NL3D_Landscape_Render_SoftGeomorph );
// If software GeoMorph / Alpha Transition (no VertexShader), do it now.
if(!_VertexShaderOk)
{
// For all patch visible, compute geomoprh and alpha in software.
for(it= Zones.begin();it!=Zones.end();it++)
{
if((*it).second->ClipResult==CZone::ClipOut)
continue;
for(sint i=0;i<(*it).second->getNumPatchs(); i++)
{
CPatch *patch= (*it).second->getPatch(i);
// If visible, compute Geomorph And Alpha
patch->computeSoftwareGeomorphAndAlpha();
}
}
/*
Optim note: here, lot of vertices are
1/ geomorphed twice (vertices on edges of patchs)
2/ vertices are geomorphed, but not used (because o the Tessblock clip),
because lot of vertices used by faces in small TessBlocks are still in MasterBlock.
Some tries have been made to solve this, but result are even worse (2 times or more), because:
1/
- does not really matter edges of patchs (and corner) because the majority is in interior of patch.
- in this case, we need to reset all the flags which is very costly (reparse all zones...) .
2/ Except for the old CTessBlockEdge management which not solve all the thing, the other solution is
to test all faces not clipped (on a per TessBlock basis), to compute only vertices needed.
But in this cases, result are worse, maybe because there is 6 times more tests, and with bad BTB cache.
*/
}
H_AFTER( NL3D_Landscape_Render_SoftGeomorph );
// Must realase VB Buffers Now!! The VBuffers are now OK!
// NB: no parallelism is made between 3dCard and Fill of vertices.
// We Suppose Fill of vertices is rare, and so do not need to be parallelized.
unlockBuffers(true);
// If VertexShader enabled, setup VertexProgram Constants.
if(_VertexShaderOk)
{
// c[0..3] take the ModelViewProjection Matrix.
driver->setConstantMatrix(0, IDriver::ModelViewProjection, IDriver::Identity);
// c[4] take useful constants.
driver->setConstant(4, 0, 1, 0.5f, 0);
// c[5] take RefineCenter
driver->setConstant(5, refineCenter);
// c[6] take info for Geomorph trnasition to TileNear.
driver->setConstant(6, CLandscapeGlobals::TileDistFarSqr, CLandscapeGlobals::OOTileDistDeltaSqr, 0, 0);
// c[10] take the fog vector.
driver->setConstantFog(10);
// c[12] take the current landscape Center / delta Pos to apply
driver->setConstant(12, _PZBModelPosition);
}
// 1. TileRender pass.
//====================
// Yoyo: profile
NL3D_PROFILE_LAND_SET(ProfNTileSetupMaterial, driver->profileSetupedMaterials() );
H_BEFORE( NL3D_Landscape_Render_Tile );
// First, update Dynamic Lighting for Near, ie multiply Dynamic Lightmap with UserColor, and upload to texture.
// ==================
CPatchDLMContext *dlmCtxPtr= _PatchDLMContextList->begin();
while(dlmCtxPtr!=NULL)
{
// do it only if the patch has some Near stuff to render, and if it is visible
if(dlmCtxPtr->getPatch()->getFar0() == 0
&& !dlmCtxPtr->getPatch()->isRenderClipped() )
{
// upload lightmap into textureDLM, modulating before with patch TileColor.
// NB: no-op if both src and dst are already full black.
dlmCtxPtr->compileLighting(CPatchDLMContext::ModulateTileColor);
}
// next
dlmCtxPtr= (CPatchDLMContext*)dlmCtxPtr->Next;
}
// Active VB.
// ==================
// Active the good VB, and maybe activate the VertexProgram Nb 0.
_TileVB.activate(0);
// Render.
// ==================
// Before any render call. Set the global driver used to render.
CLandscapeGlobals::PatchCurrentDriver= driver;
// bkup the original fog color
CRGBA fogColor= driver->getFogColor();
// Render Order. Must "invert", since initial order is NOT the render order. This is done because the lightmap pass
// DO NOT have to do any renderTile(), since it is computed in RGB0 pass.
nlassert(NL3D_MAX_TILE_PASS==5);
static sint RenderOrder[NL3D_MAX_TILE_PASS]= {NL3D_TILE_PASS_RGB0, NL3D_TILE_PASS_RGB1, NL3D_TILE_PASS_RGB2,
NL3D_TILE_PASS_LIGHTMAP, NL3D_TILE_PASS_ADD};
// For ALL pass..
for(i=0; i<NL3D_MAX_TILE_PASS; i++)
{
sint passOrder= RenderOrder[i];
// If VertexShader enabled, and if lightmap or post Add pass, must setup good VertexProgram
if(_VertexShaderOk)
{
if(passOrder == NL3D_TILE_PASS_LIGHTMAP)
{
// Must activate the vertexProgram to take TexCoord2 to stage0
_TileVB.activate(1);
}
else if(passOrder == NL3D_TILE_PASS_ADD)
{
// Must re-activate the standard VertexProgram
_TileVB.activate(0);
}
}
// Do add pass???
if((passOrder==NL3D_TILE_PASS_ADD) && !doTileAddPass)
continue;
// Setup common material for this pass.
//=============================
// Default: Replace envmode.
TileMaterial.texEnvOpRGB(0, CMaterial::Replace);
TileMaterial.texEnvArg0RGB(0, CMaterial::Texture, CMaterial::SrcColor);
TileMaterial.texEnvOpAlpha(0, CMaterial::Replace);
TileMaterial.texEnvArg0Alpha(0, CMaterial::Texture, CMaterial::SrcAlpha);
// NB: important to set Replace and not modulate, because in case of VerexProgram enabled,
// Diffuse o[COL0] is undefined.
// Copy from stage 0 to stage 1.
TileMaterial.setTexEnvMode(1, TileMaterial.getTexEnvMode(0));
// setup multitex / blending.
if(passOrder==NL3D_TILE_PASS_RGB0)
{
// first pass, no blend.
TileMaterial.setBlend(false);
}
else
{
TileMaterial.setBlend(true);
switch(passOrder)
{
case NL3D_TILE_PASS_RGB1:
case NL3D_TILE_PASS_RGB2:
// alpha blending.
TileMaterial.setBlendFunc(CMaterial::srcalpha, CMaterial::invsrcalpha);
// Must use a special envmode for stage1: "separateAlpha"!!.
// keep the color from previous stage.
TileMaterial.texEnvOpRGB(1, CMaterial::Replace);
TileMaterial.texEnvArg0RGB(1, CMaterial::Previous, CMaterial::SrcColor);
// take the alpha from current stage.
TileMaterial.texEnvOpAlpha(1, CMaterial::Replace);
TileMaterial.texEnvArg0Alpha(1, CMaterial::Texture, CMaterial::SrcAlpha);
break;
case NL3D_TILE_PASS_LIGHTMAP:
// modulate alpha blending.
TileMaterial.setBlendFunc(CMaterial::zero, CMaterial::srccolor);
// Setup the material envCombine so DynamicLightmap (stage 0) is added to static lightmap.
TileMaterial.texEnvOpRGB(1, CMaterial::Add);
TileMaterial.texEnvArg0RGB(1, CMaterial::Texture, CMaterial::SrcColor);
TileMaterial.texEnvArg1RGB(1, CMaterial::Previous, CMaterial::SrcColor);
break;
case NL3D_TILE_PASS_ADD:
// Use srcalpha for src (and not ONE), since additive are blended with alpha Cte/AlphaTexture
TileMaterial.setBlendFunc(CMaterial::srcalpha, CMaterial::one);
// for MAYBE LATER smooth night transition, setup Alpha cte of stage0, and setup alpha stage.
TileMaterial.texEnvOpAlpha(0, CMaterial::Replace);
TileMaterial.texEnvArg0Alpha(0, CMaterial::Constant, CMaterial::SrcAlpha);
// Temp, just setup alpha to 1.
TileMaterial.texConstantColor(0, CRGBA(255, 255, 255, 255));
// Must use a special envmode for stage1: "separateAlpha"!!.
// NB: it still works if The RdrPass has no texture.
// keep the color from previous stage.
TileMaterial.texEnvOpRGB(1, CMaterial::Replace);
TileMaterial.texEnvArg0RGB(1, CMaterial::Previous, CMaterial::SrcColor);
// modulate the alpha of current stage with previous
TileMaterial.texEnvOpAlpha(1, CMaterial::Modulate);
TileMaterial.texEnvArg0Alpha(1, CMaterial::Texture, CMaterial::SrcAlpha);
TileMaterial.texEnvArg1Alpha(1, CMaterial::Previous, CMaterial::SrcAlpha);
break;
default:
nlstop;
};
}
// Reset the textures (so there is none in Addtive pass or in Lightmap).
TileMaterial.setTexture(0, NULL);
TileMaterial.setTexture(1, NULL);
TileMaterial.setTexture(2, NULL);
// Render All material RdrPass.
//=============================
// Special code for Lightmap and RGB0, for faster render.
if(passOrder==NL3D_TILE_PASS_RGB0)
{
// for RGB0 pass, setup the normal fogColor
driver->setupFog(driver->getFogStart(), driver->getFogEnd(), fogColor);
// RGB0 pass.
ItTileRdrPassSet itTile;
for(itTile= TileRdrPassSet.begin(); itTile!= TileRdrPassSet.end(); itTile++)
{
// Get a ref on the render pass. Const cast work because we only modify attribut from CPatchRdrPass
// that don't affect the operator< of this class
CPatchRdrPass &pass= const_cast<CPatchRdrPass&>(*itTile);
// Enlarge PassTriArray as needed
CRdrTileId *tileToRdr= pass.getRdrTileRoot(passOrder);
uint32 numWantedIndex = countNumWantedIndex(tileToRdr, NL3D_TILE_PASS_RGB0);
if (numWantedIndex)
{
initPassTriArray(pass, numWantedIndex);
// Setup Diffuse texture of the tile.
TileMaterial.setTexture(0, pass.TextureDiffuse);
// Add triangles to array
while(tileToRdr)
{
// renderSimpleTriangles() with the material setuped.
tileToRdr->TileMaterial->renderTilePassRGB0();
tileToRdr= (CRdrTileId*)tileToRdr->getNext();
}
// Render triangles.
drawPassTriArray(TileMaterial);
}
}
}
else if(passOrder==NL3D_TILE_PASS_LIGHTMAP)
{
// for Lightmap pass (modulate blend), setup a White fogColor. This is not
// mathematically correct but works fine
driver->setupFog(driver->getFogStart(), driver->getFogEnd(), CRGBA::White);
// Lightmap Pass.
/* \todo yoyo: TODO_CLOUD: setup stage2, and setup texcoord generation. COMPLEX because of interaction
with Dynamic LightMap
*/
// Setup the Dynamic Lightmap into stage 0.
TileMaterial.setTexture(0, _TextureDLM);
// if vertex shader not used.
if(!_VertexShaderOk)
{
// special setup such that stage0 takes Uv2.
driver->mapTextureStageToUV(0, 2);
}
// else VertexProgram map itself the good vertex Attribute to UV0.
// Render All the lightmaps.
for(sint lightRdrPass=0; lightRdrPass<(sint)_TextureNears.size(); lightRdrPass++)
{
CPatchRdrPass &pass= *_TextureNears[lightRdrPass];
// Enlarge PassTriArray as needed
CRdrTileId *tileToRdr= pass.getRdrTileRoot(passOrder);
uint32 numWantedIndex = countNumWantedIndex(tileToRdr, NL3D_TILE_PASS_RGB0);
if (numWantedIndex)
{
initPassTriArray(pass, numWantedIndex);
// Setup Lightmap into stage1. Because we share UV with pass RGB0. So we use UV1.
// Also, now stage0 is used for DynamicLightmap
TileMaterial.setTexture(1, pass.TextureDiffuse);
// Add triangles to array
while(tileToRdr)
{
// renderSimpleTriangles() with the material setuped.
tileToRdr->TileMaterial->renderTilePassLightmap();
tileToRdr= (CRdrTileId*)tileToRdr->getNext();
}
// Render triangles.
drawPassTriArray(TileMaterial);
}
}
// if vertex shader not used.
if(!_VertexShaderOk)
{
// Reset special stage/UV setup to normal behavior
driver->mapTextureStageToUV(0, 0);
}
}
else
{
// RGB1, RGB2, and ADD pass.
// for ADD pass (additive blend), setup a Black fogColor
if(passOrder==NL3D_TILE_PASS_ADD)
driver->setupFog(driver->getFogStart(), driver->getFogEnd(), CRGBA::Black);
// else setup the standard color (std blend)
else
driver->setupFog(driver->getFogStart(), driver->getFogEnd(), fogColor);
// Render Base, Transitions or Additives.
ItTileRdrPassSet itTile;
for(itTile= TileRdrPassSet.begin(); itTile!= TileRdrPassSet.end(); itTile++)
{
// Get a ref on the render pass. Const cast work because we only modify attribut from CPatchRdrPass
// that don't affect the operator< of this class
CPatchRdrPass &pass= const_cast<CPatchRdrPass&>(*itTile);
// Enlarge PassTriArray as needed
CRdrTileId *tileToRdr= pass.getRdrTileRoot(passOrder);
uint32 numWantedIndex = countNumWantedIndex(tileToRdr, passOrder);
if (numWantedIndex)
{
initPassTriArray(pass, numWantedIndex);
// Add triangles to array
while(tileToRdr)
{
// renderSimpleTriangles() with the material setuped.
tileToRdr->TileMaterial->renderTile(passOrder);
tileToRdr= (CRdrTileId*)tileToRdr->getNext();
}
// Pass not empty ?
if(NL3D_LandscapeGlobals_PassNTri>0)
{
// Setup material.
// Setup Diffuse texture of the tile.
TileMaterial.setTexture(0, pass.TextureDiffuse);
// If transition tile, must enable the alpha for this pass.
// NB: Additive pass may have pass.TextureAlpha==NULL
TileMaterial.setTexture(1, pass.TextureAlpha);
}
// Render triangles.
drawPassTriArray(TileMaterial);
}
}
}
}
// restore old fog color
driver->setupFog(driver->getFogStart(), driver->getFogEnd(), fogColor);
// Yoyo: profile
NL3D_PROFILE_LAND_SET(ProfNTileSetupMaterial, driver->profileSetupedMaterials()-ProfNTileSetupMaterial );
H_AFTER( NL3D_Landscape_Render_Tile );
// 2. Far0Render pass.
//====================
// Yoyo: profile
NL3D_PROFILE_LAND_SET(ProfNFar0SetupMaterial, driver->profileSetupedMaterials() );
H_BEFORE( NL3D_Landscape_Render_DLM );
// First, update Dynamic Lighting for Far, ie multiply Dynamic Lightmap with TextureFar, and upload to texture.
// ==================
dlmCtxPtr= _PatchDLMContextList->begin();
while(dlmCtxPtr!=NULL)
{
// do it only if the patch has some Far stuff to render, and if it is visible
if( (dlmCtxPtr->getPatch()->getFar0()>0 || dlmCtxPtr->getPatch()->getFar1()>0)
&& !dlmCtxPtr->getPatch()->isRenderClipped() )
{
// upload lightmap into textureDLM, modulating before with patch TextureFar.
// NB: no-op if both src and dst are already full black.
dlmCtxPtr->compileLighting(CPatchDLMContext::ModulateTextureFar);
}
// next
dlmCtxPtr= (CPatchDLMContext*)dlmCtxPtr->Next;
}
H_AFTER( NL3D_Landscape_Render_DLM );
H_BEFORE( NL3D_Landscape_Render_Far0 );
// Active VB.
// ==================
// Active the good VB, and maybe activate the std VertexProgram.
_Far0VB.activate(0);
// Render.
// ==================
// Setup common material.
FarMaterial.setBlend(false);
// set the DLM texture.
FarMaterial.setTexture(1, _TextureDLM);
// Render All material RdrPass0.
itFar=_TextureFars.begin();
while (itFar!=_TextureFars.end())
{
CPatchRdrPass &pass= **itFar;
// Enlarge PassTriArray as needed
CPatch *patchToRdr= pass.getRdrPatchFar0();
if (patchToRdr)
{
uint32 numWantedIndex = countNumWantedIndexFar0(patchToRdr);
if (numWantedIndex)
{
initPassTriArray(pass, numWantedIndex);
// Setup the material.
FarMaterial.setTexture(0, pass.TextureDiffuse);
// If the texture need to be updated, do it now.
if(pass.TextureDiffuse && pass.TextureDiffuse->touched())
driver->setupTexture(*pass.TextureDiffuse);
// Add triangles to array
while(patchToRdr)
{
// renderSimpleTriangles() with the material setuped.
patchToRdr->renderFar0();
patchToRdr= patchToRdr->getNextFar0ToRdr();
}
// Render triangles.
drawPassTriArray(FarMaterial);
}
}
// Next render pass
itFar++;
}
// Yoyo: profile
NL3D_PROFILE_LAND_SET(ProfNFar0SetupMaterial, driver->profileSetupedMaterials()-ProfNFar0SetupMaterial );
H_AFTER( NL3D_Landscape_Render_Far0 );
// 3. Far1Render pass.
//====================
// Yoyo: profile
NL3D_PROFILE_LAND_SET(ProfNFar1SetupMaterial, driver->profileSetupedMaterials() );
H_BEFORE( NL3D_Landscape_Render_Far1 );
// Active VB.
// ==================
// Active the good VB, and maybe activate the std VertexProgram.
_Far1VB.activate(0);
// Render
// ==================
// Setup common material.
FarMaterial.setBlend(true);
// set the DLM texture.
FarMaterial.setTexture(1, _TextureDLM);
// Render All material RdrPass1.
itFar=_TextureFars.begin();
while (itFar!=_TextureFars.end())
{
CPatchRdrPass &pass= **itFar;
// Enlarge PassTriArray as needed
CPatch *patchToRdr= pass.getRdrPatchFar1();
if (patchToRdr)
{
//uint32 numWantedIndex = countNumWantedIndexFar1(patchToRdr);
uint32 numWantedIndex = countNumWantedIndexFar1(patchToRdr);
if (numWantedIndex)
{
initPassTriArray(pass, numWantedIndex);
// Setup the material.
FarMaterial.setTexture(0, pass.TextureDiffuse);
// If the texture need to be updated, do it now.
if(pass.TextureDiffuse && pass.TextureDiffuse->touched())
driver->setupTexture(*pass.TextureDiffuse);
// Add triangles to array
while(patchToRdr)
{
// renderSimpleTriangles() with the material setuped.
patchToRdr->renderFar1();
patchToRdr= patchToRdr->getNextFar1ToRdr();
}
// Render triangles.
drawPassTriArray(FarMaterial);
}
}
// Next render pass
itFar++;
}
// Yoyo: profile
NL3D_PROFILE_LAND_SET(ProfNFar1SetupMaterial, driver->profileSetupedMaterials()-ProfNFar1SetupMaterial );
H_AFTER( NL3D_Landscape_Render_Far1 );
// 4. "Release" texture materials.
//================================
FarMaterial.setTexture(0, NULL);
FarMaterial.setTexture(1, NULL);
FarMaterial.setTexture(2, NULL);
FarMaterial.setTexture(3, NULL);
TileMaterial.setTexture(0, NULL);
TileMaterial.setTexture(1, NULL);
TileMaterial.setTexture(2, NULL);
TileMaterial.setTexture(3, NULL);
// To ensure no use but in render()..
CLandscapeGlobals::PatchCurrentDriver= NULL;
// Desactive the vertex program (if anyone)
if(_VertexShaderOk)
driver->activeVertexProgram (NULL);
// 5. Vegetable Management.
//================================
if(scene && scene->getLandscapePolyDrawingCallback())
{
scene->getLandscapePolyDrawingCallback()->endPolyDrawing();
}
// First, update Dynamic Lighting for Vegetable, ie just copy.
// ==================
if(isVegetableActive())
{
/* Actually we modulate the DLM with an arbitrary constant for this reason:
Color of vegetable (ie their material) are NOT modulated with DLM.
Doing this without using PixelShader / additional UVs seems to be impossible.
And add new UVs (+700K in AGP) just for this is not worth the effort.
We prefer using a constant to simulate the "global vegetable color", which is a big trick.
Additionally, the vegetable take the diffuse lighting of landscape, which is
false because it replaces the diffuse lighting it should have (ie with his own Normal and
his own "global vegetable color")
We can't do anything for "correct normal vegetable", but it is possible to replace landscape
material with vegetable material, by dividing _DLMGlobalVegetableColor by LandscapeDiffuseMaterial.
This is a very approximate result because of CRGBA clamp, but it is acceptable.
*/
CRGBA vegetDLMCte;
// the constant is _DLMGlobalVegetableColor / PointLightDiffuseMaterial
uint v;
v= (_DLMGlobalVegetableColor.R*256) / (_PointLightDiffuseMaterial.R+1);
vegetDLMCte.R= (uint8)min(v, 255U);
v= (_DLMGlobalVegetableColor.G*256) / (_PointLightDiffuseMaterial.G+1);
vegetDLMCte.G= (uint8)min(v, 255U);
v= (_DLMGlobalVegetableColor.B*256) / (_PointLightDiffuseMaterial.B+1);
vegetDLMCte.B= (uint8)min(v, 255U);
// Parse all patch which have some vegetables
dlmCtxPtr= _PatchDLMContextList->begin();
while(dlmCtxPtr!=NULL)
{
// do it only if the patch has some vegetable stuff to render, and if it is visible
// NB: we may have some vegetable stuff to render if the patch has some TileMaterial created.
if(dlmCtxPtr->getPatch()->getTileMaterialRefCount()>0
&& !dlmCtxPtr->getPatch()->isRenderClipped() )
{
// NB: no-op if both src and dst are already full black.
dlmCtxPtr->compileLighting(CPatchDLMContext::ModulateConstant, vegetDLMCte);
}
// next
dlmCtxPtr= (CPatchDLMContext*)dlmCtxPtr->Next;
}
}
// profile.
_VegetableManager->resetNumVegetableFaceRendered();
// render all vegetables, only if driver support VertexProgram.
// ==================
if(isVegetableActive())
{
// Use same plane as TessBlock for faster clipping.
vector<CPlane> vegetablePyramid;
vegetablePyramid.resize(NL3D_TESSBLOCK_NUM_CLIP_PLANE);
for(i=0;i<NL3D_TESSBLOCK_NUM_CLIP_PLANE;i++)
{
vegetablePyramid[i]= pyramid[i];
}
_VegetableManager->render(refineCenter, frontVector, vegetablePyramid, _TextureDLM, driver);
}
}
// ***************************************************************************
// ***************************************************************************
// Tile mgt.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
ITexture *CLandscape::findTileTexture(const std::string &textName, bool clamp)
{
ITexture *text;
text= TileTextureMap[textName];
// If just inserted, RefPtr is NULL!! :)
// This test too if the RefPtr is NULL... (tile released)
// The object is not owned by this map. It will be own by the multiple RdrPass via CSmartPtr.
// They will destroy it when no more points to them.
if(!text)
{
TileTextureMap[textName]= text= new CTextureFile(textName);
text->setWrapS(clamp?ITexture::Clamp:ITexture::Repeat);
text->setWrapT(clamp?ITexture::Clamp:ITexture::Repeat);
text->setUploadFormat(ITexture::DXTC5);
text->setTextureCategory(_TextureTileCategory);
}
return text;
}
// ***************************************************************************
CPatchRdrPass *CLandscape::findTileRdrPass(const CPatchRdrPass &pass)
{
ItTileRdrPassSet it;
// If already here, find it, else insert.
it= (TileRdrPassSet.insert(pass)).first;
return const_cast<CPatchRdrPass*>(&(*it));
}
// ***************************************************************************
void CLandscape::loadTile(uint16 tileId)
{
CTile *tile;
CTileInfo *tileInfo;
string textName;
// Retrieve or create texture.
// ===========================
// Tile Must exist.
// nlassert(tileId==0xFFFF || tileId<TileBank.getTileCount());
if(tileId<TileBank.getTileCount())
tile= TileBank.getTile(tileId);
else
tile= NULL;
// TileInfo must not exist.
nlassert(TileInfos[tileId]==NULL);
TileInfos[tileId]= tileInfo= new CTileInfo;
// Fill additive part.
// ===================
if(tile)
textName= tile->getRelativeFileName(CTile::additive);
else
textName= "";
// If no additive for this tile, rdrpass is NULL.
if(textName=="")
tileInfo->AdditiveRdrPass= NULL;
else
{
// Fill rdrpass.
CPatchRdrPass pass;
// Avoid using Clamp for diffuse, because of recent NVidia GL drivers Bugs in 77.72
pass.TextureDiffuse= findTileTexture(TileBank.getAbsPath()+textName, false);
// We may have an alpha part for additive.
textName= tile->getRelativeFileName (CTile::alpha);
if(textName!="")
// Must Use clamp for alpha (although NVidia drivers are buggy), because the texture doesn't tile at all
pass.TextureAlpha= findTileTexture(TileBank.getAbsPath()+textName, true);
// Fill tileInfo.
tileInfo->AdditiveRdrPass= findTileRdrPass(pass);
// Fill UV Info.
// NB: for now, One Tile== One Texture, so UVScaleBias is simple.
tileInfo->AdditiveUvScaleBias.x= 0;
tileInfo->AdditiveUvScaleBias.y= 0;
tileInfo->AdditiveUvScaleBias.z= 1;
}
// Fill diffuse part.
// =======================
// Fill rdrpass.
CPatchRdrPass pass;
// The diffuse part for a tile is inevitable.
if(tile)
{
textName= tile->getRelativeFileName(CTile::diffuse);
if(textName!="")
// Avoid using Clamp for diffuse, because of recent NVidia GL drivers Bugs in 77.72
pass.TextureDiffuse= findTileTexture(TileBank.getAbsPath()+textName, false);
else
{
pass.TextureDiffuse= new CTextureCross;
nldebug("Missing Tile diffuse texname: %d", tileId);
}
}
else
pass.TextureDiffuse= new CTextureCross;
if(tile)
{
textName= tile->getRelativeFileName (CTile::alpha);
if(textName!="")
// Must Use clamp for alpha (although NVidia drivers are buggy), because the texture doesn't tile at all
pass.TextureAlpha= findTileTexture(TileBank.getAbsPath()+textName, true);
}
// Fill tileInfo.
tileInfo->DiffuseRdrPass= findTileRdrPass(pass);
// Fill UV Info.
// NB: for now, One Tile== One Texture, so UVScaleBias is simple.
tileInfo->DiffuseUvScaleBias.x= 0;
tileInfo->DiffuseUvScaleBias.y= 0;
tileInfo->DiffuseUvScaleBias.z= 1;
tileInfo->AlphaUvScaleBias.x= 0;
tileInfo->AlphaUvScaleBias.y= 0;
tileInfo->AlphaUvScaleBias.z= 1;
// Retrieve the good rot alpha decal.
if(tile)
tileInfo->RotAlpha= tile->getRotAlpha();
else
tileInfo->RotAlpha= 0;
// Increment RefCount of RenderPart.
// =================================
if(tileInfo->AdditiveRdrPass)
tileInfo->AdditiveRdrPass->RefCount++;
if(tileInfo->DiffuseRdrPass)
tileInfo->DiffuseRdrPass->RefCount++;
}
// ***************************************************************************
void CLandscape::releaseTile(uint16 tileId)
{
CTileInfo *tileInfo;
tileInfo= TileInfos[tileId];
nlassert(tileInfo!=NULL);
// "Release" the rdr pass.
if(tileInfo->AdditiveRdrPass)
tileInfo->AdditiveRdrPass->RefCount--;
if(tileInfo->DiffuseRdrPass)
tileInfo->DiffuseRdrPass->RefCount--;
delete tileInfo;
TileInfos[tileId]= NULL;
}
// ***************************************************************************
CPatchRdrPass *CLandscape::getTileRenderPass(uint16 tileId, bool additiveRdrPass)
{
CTileInfo *tile= TileInfos[tileId];
// If not here, create it.
//========================
if(tile==NULL)
{
// Force loading of tile.
loadTile(tileId);
tile= TileInfos[tileId];
nlassert(tile!=NULL);
}
// Retrieve.
//========================
if(additiveRdrPass)
{
// NB: additive pass is not lighted by the lightmap, so there is no lighted version of this rednerpass.
return tile->AdditiveRdrPass;
}
else
{
return tile->DiffuseRdrPass;
}
}
// ***************************************************************************
void CLandscape::getTileUvScaleBiasRot(uint16 tileId, CTile::TBitmap bitmapType, CVector &uvScaleBias, uint8 &rotAlpha)
{
CTileInfo *tile= TileInfos[tileId];
// tile should not be NULL.
// Because load of tiles are always done in getTileRenderPass(), and this insertion always succeed.
nlassert(tile);
rotAlpha= 0;
switch(bitmapType)
{
case CTile::diffuse:
uvScaleBias= tile->DiffuseUvScaleBias; break;
case CTile::additive:
uvScaleBias= tile->AdditiveUvScaleBias; break;
case CTile::alpha:
uvScaleBias= tile->AlphaUvScaleBias;
rotAlpha= tile->RotAlpha;
break;
default: break;
}
}
// ***************************************************************************
NLMISC::CSmartPtr<ITexture> CLandscape::getTileTexture(uint16 tileId, CTile::TBitmap bitmapType, CVector &uvScaleBias)
{
CPatchRdrPass *pass;
if(bitmapType== CTile::additive)
pass= getTileRenderPass(tileId, true);
else
pass= getTileRenderPass(tileId, false);
if(!pass)
return NULL;
uint8 dummy;
getTileUvScaleBiasRot(tileId, bitmapType, uvScaleBias, dummy);
// return the wanted texture.
if(bitmapType==CTile::diffuse || bitmapType==CTile::additive)
return pass->TextureDiffuse;
else
return pass->TextureAlpha;
}
// ***************************************************************************
CTileElement *CLandscape::getTileElement(const CPatchIdent &patchId, const CUV &uv)
{
// \todo yoyo: TODO_ZONEID: change ZoneId in 32 bits...
std::map<uint16, CZone*>::const_iterator it= Zones.find((uint16)patchId.ZoneId);
if(it!=Zones.end())
{
sint N= (*it).second->getNumPatchs();
// patch must exist in the zone.
nlassert(patchId.PatchId<N);
CPatch *pa= const_cast<CZone*>((*it).second)->getPatch(patchId.PatchId);
return pa->getTileElement (uv);
}
else
// Return not found
return NULL;
}
// ***************************************************************************
void CLandscape::flushTiles(IDriver *drv, uint32 tileStart, uint32 nbTiles)
{
nlassert(nbTiles<=65536);
nlassert(tileStart+nbTiles<=65536);
// Load tile rdrpass, force setup the texture.
for(sint tileId= tileStart; tileId<(sint)(tileStart+nbTiles); tileId++)
{
CTileInfo *tile= TileInfos[tileId];
if(tile==NULL)
{
loadTile(uint16(tileId));
CTileInfo *tile= TileInfos[tileId];
nlassert(tile);
if(tile->DiffuseRdrPass)
{
const CPatchRdrPass &pass= *tile->DiffuseRdrPass;
// If present and not already setuped...
if(pass.TextureDiffuse && !pass.TextureDiffuse->setupedIntoDriver())
drv->setupTexture(*pass.TextureDiffuse);
// If present and not already setuped...
if(pass.TextureAlpha && !pass.TextureAlpha->setupedIntoDriver())
drv->setupTexture(*pass.TextureAlpha);
}
if(tile->AdditiveRdrPass)
{
const CPatchRdrPass &pass= *tile->AdditiveRdrPass;
// If present and not already setuped...
if(pass.TextureDiffuse && !pass.TextureDiffuse->setupedIntoDriver())
drv->setupTexture(*pass.TextureDiffuse);
// If present and not already setuped...
if(pass.TextureAlpha && !pass.TextureAlpha->setupedIntoDriver())
drv->setupTexture(*pass.TextureAlpha);
}
}
}
}
// ***************************************************************************
void CLandscape::releaseTiles(uint32 tileStart, uint32 nbTiles)
{
nlassert(nbTiles<=65536);
nlassert(tileStart+nbTiles<=65536);
// release tiles.
for(sint tileId= tileStart; tileId<(sint)(tileStart+nbTiles); tileId++)
{
CTileInfo *tile= TileInfos[tileId];
if(tile!=NULL)
{
releaseTile(uint16(tileId));
}
}
// For all rdrpass, release one that are no more referenced.
ItTileRdrPassSet it;
for(it= TileRdrPassSet.begin(); it!=TileRdrPassSet.end();)
{
// If no more tile access the rdrpass, delete it.
if((*it).RefCount==0)
{
ItTileRdrPassSet itDel=it++;
TileRdrPassSet.erase(itDel);
}
else
it++;
}
// Textures are automaticly deleted by smartptr, but not their entry int the map (TileTextureMap).
// => doesn't matter since findTileTexture() manages this case.
// And the memory overhead is not a problem (we talk about pointers).
}
// ***************************************************************************
uint CLandscape::getTileLightMap(CRGBA map[NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE], CPatchRdrPass *&lightmapRdrPass)
{
sint textNum;
uint lightMapId;
/*
NB: TextureNear are a grow only Array... TextureNear are never deleted. Why? :
2/ Unused near texture may be uncahced by opengl (and maybe by windows, to disk).
(old reason, no longer valid, since lightmaps are unlinked from tiles.
1/ There is an important issue with releasing texture nears: tiles may acces them (see getTileRenderPass())
)
*/
// 0. Alloc Near Texture if necessary.
//====================================
if(_NFreeLightMaps==0)
{
CTextureNear *text= new CTextureNear(TextureNearSize);
TSPRenderPass newPass= new CPatchRdrPass;
text->setTextureCategory(_TextureNearCategory);
newPass->TextureDiffuse= text;
_TextureNears.push_back(newPass);
_NFreeLightMaps+= text->getNbAvailableTiles();
}
// 1. Search the first texture which has a free tile.
//==================================================
CTextureNear *nearText= NULL;
CPatchRdrPass *nearRdrPass= NULL;
for(textNum=0;textNum<(sint)_TextureNears.size();textNum++)
{
nearRdrPass= _TextureNears[textNum];
nearText= (CTextureNear*)(ITexture*)nearRdrPass->TextureDiffuse;
if(nearText->getNbAvailableTiles()!=0)
break;
}
nlassert(textNum<(sint)_TextureNears.size());
// A empty space has been found.
_NFreeLightMaps--;
// 2. Fill the texture with the data, and updaterect.
//===================================================
lightMapId= nearText->getTileAndFillRect(map);
// Compute the Id.
lightMapId= textNum*NbTileLightMapByTexture + lightMapId;
// 3. updateLighting
//===================================================
// Increment number of pixels to update for near.
_ULTotalNearPixels+= NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE;
// Result:
lightmapRdrPass= nearRdrPass;
return lightMapId;
}
// ***************************************************************************
void CLandscape::getTileLightMapUvInfo(uint tileLightMapId, CVector &uvScaleBias)
{
uint id, s,t;
// Scale.
static const float scale10= (float)NL_TILE_LIGHTMAP_SIZE/TextureNearSize;
static const float scale4= 4.f/TextureNearSize;
static const float scale1= 1.f/TextureNearSize;
// The size of a minilightmap, mapped onto the polygon, is still 4 pixels.
uvScaleBias.z= scale4;
// Get the id local in the texture.
id= tileLightMapId%NbTileLightMapByTexture;
// Commpute UVBias.
// Get the coordinate of the tile, in tile number.
s= id%NbTileLightMapByLine;
t= id/NbTileLightMapByLine;
// But the real size of a minilightmap is 10 pixels, and we must reach the pixel 1,1.
uvScaleBias.x= s*scale10 + scale1;
uvScaleBias.y= t*scale10 + scale1;
}
// ***************************************************************************
void CLandscape::releaseTileLightMap(uint tileLightMapId)
{
uint id, textNum;
// Get the id local in the texture.
textNum= tileLightMapId / NbTileLightMapByTexture;
id= tileLightMapId % NbTileLightMapByTexture;
nlassert(textNum<_TextureNears.size());
// Release the tile in this texture.
CPatchRdrPass *nearRdrPass= _TextureNears[textNum];
CTextureNear *nearText= (CTextureNear*)(ITexture*)nearRdrPass->TextureDiffuse;
nearText->releaseTile(id);
_NFreeLightMaps++;
// updateLighting
// Decrement number of pixels to update for near.
_ULTotalNearPixels-= NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE;
}
// ***************************************************************************
void CLandscape::refillTileLightMap(uint tileLightMapId, CRGBA map[NL_TILE_LIGHTMAP_SIZE*NL_TILE_LIGHTMAP_SIZE])
{
uint id, textNum;
// Get the id local in the texture.
textNum= tileLightMapId / NbTileLightMapByTexture;
id= tileLightMapId % NbTileLightMapByTexture;
nlassert(textNum<_TextureNears.size());
// get a ptr on the texture.
CPatchRdrPass *nearRdrPass= _TextureNears[textNum];
CTextureNear *nearText= (CTextureNear*)(ITexture*)nearRdrPass->TextureDiffuse;
// refill this tile
nearText->refillRect(id, map);
}
// ***************************************************************************
// ***************************************************************************
// Far.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CPatchRdrPass* CLandscape::getFarRenderPass(CPatch* pPatch, uint farIndex, float& farUScale, float& farVScale, float& farUBias, float& farVBias, bool& bRot)
{
// Check args
nlassert (farIndex>0);
// Get size of the far texture
uint width=(pPatch->getOrderS ()*NL_NUM_PIXELS_ON_FAR_TILE_EDGE)>>(farIndex-1);
uint height=(pPatch->getOrderT ()*NL_NUM_PIXELS_ON_FAR_TILE_EDGE)>>(farIndex-1);
// For updateLighting: increment total of pixels to update.
_ULTotalFarPixels+= width*height;
// Try to allocate in every textures
uint i;
sint bestRdrPass= -1;
sint bestSplit= INT_MAX;
for(i=0;i<_TextureFars.size();i++)
{
CTextureFar *pTextureFar=(CTextureFar*)(&*(_TextureFars[i]->TextureDiffuse));
sint splitRes= pTextureFar->tryAllocatePatch(pPatch, farIndex);
// if found with no split, ok, stop!
if(splitRes==0)
{
bestRdrPass= i;
break;
}
// else if found, but with split
else if(splitRes > 0)
{
// Then must take the small split possible along all the texture fars.
if (splitRes<bestSplit)
{
bestRdrPass= i;
bestSplit= splitRes;
}
}
}
// If no one found, must allocate a new render pass.
if(bestRdrPass==-1)
{
bestRdrPass= _TextureFars.size();
// add a new render pass
CPatchRdrPass *pass=new CPatchRdrPass;
// Fill the render pass
CTextureFar *pTextureFar=new CTextureFar;
pTextureFar->setTextureCategory(_TextureFarCategory);
// Append this textureFar to the list of TextureFar to updateLighting.
if(_ULRootTextureFar==NULL)
_ULRootTextureFar= pTextureFar;
else
pTextureFar->linkBeforeUL(_ULRootTextureFar);
// Set the bank
pTextureFar->_Bank=&TileFarBank;
// Set as diffuse texture for this renderpass
pass->TextureDiffuse=pTextureFar;
// Add the render pass to the list
_TextureFars.push_back(pass);
}
// Ok, add the patch to the best render pass in the _TextureFars
TSPRenderPass pass= _TextureFars[bestRdrPass];
// Get a pointer on the diffuse far texture
CTextureFar *pTextureFar=(CTextureFar*)(&*(pass->TextureDiffuse));
// Allocate really in it (must success since tryAllocate() has succeed)
pTextureFar->allocatePatch(pPatch, farIndex, farUScale, farVScale, farUBias, farVBias, bRot);
// Return the renderpass
return pass;
}
// ***************************************************************************
void CLandscape::freeFarRenderPass (CPatch* pPatch, CPatchRdrPass* pass, uint farIndex)
{
// Get size of the far texture
uint width=(pPatch->getOrderS ()*NL_NUM_PIXELS_ON_FAR_TILE_EDGE)>>(farIndex-1);
uint height=(pPatch->getOrderT ()*NL_NUM_PIXELS_ON_FAR_TILE_EDGE)>>(farIndex-1);
// For updateLighting: decrement total of pixels to update.
_ULTotalFarPixels-= width*height;
nlassert(_ULTotalFarPixels>=0);
// Get a pointer on the diffuse far texture
CTextureFar *pTextureFar=(CTextureFar*)(&*(pass->TextureDiffuse));
// Remove from the patch from the texture if empty
pTextureFar->removePatch (pPatch, farIndex);
}
// ***************************************************************************
void CLandscape::clearFarRenderPass (CPatchRdrPass* pass)
{
// Before deleting, must remove TextureFar from UpdateLighting list.
// Get a pointer on the diffuse far texture
CTextureFar *pTextureFar=(CTextureFar*)(&*(pass->TextureDiffuse));
// If I delete the textureFar which is the current root
if(_ULRootTextureFar==pTextureFar)
{
// switch to next
_ULRootTextureFar= pTextureFar->getNextUL();
// if still the same, it means that the circular list is now empty
if(_ULRootTextureFar==pTextureFar)
_ULRootTextureFar= NULL;
}
// unlink the texture from list
pTextureFar->unlinkUL();
}
// ***************************************************************************
// ***************************************************************************
// Misc.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CZone* CLandscape::getZone (sint zoneId)
{
TZoneMap::iterator it;
it= Zones.find(uint16(zoneId));
if (it!=Zones.end())
return (*it).second;
else
return NULL;
}
// ***************************************************************************
const CZone* CLandscape::getZone (sint zoneId) const
{
TZoneMap::const_iterator it;
it= Zones.find(uint16(zoneId));
if (it!=Zones.end())
return (*it).second;
else
return NULL;
}
// ***************************************************************************
void CLandscape::checkZoneBinds(CZone &curZone, EBadBind &bindError)
{
for(sint i=0;i<curZone.getNumPatchs();i++)
{
const CZone::CPatchConnect &pa= *curZone.getPatchConnect(i);
// Check the bindInfos.
for(sint j=0;j<4;j++)
{
const CPatchInfo::CBindInfo &bd=pa.BindEdges[j];
// Just 1/1 for now.
if(bd.NPatchs==1)
{
CZone *oZone= getZone(bd.ZoneId);
// If loaded zone.
if(oZone)
{
const CZone::CPatchConnect &po= *(oZone->getPatchConnect(bd.Next[0]));
const CPatchInfo::CBindInfo &bo= po.BindEdges[bd.Edge[0]];
if(bo.NPatchs!=1 || bo.Next[0]!=i || bo.Edge[0]!=j)
bindError.BindErrors.push_back( EBadBind::CBindError(curZone.getZoneId(), i));
}
}
}
}
}
// ***************************************************************************
void CLandscape::checkBinds() throw(EBadBind)
{
EBadBind bindError;
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
CZone &curZone= *(*it).second;
checkZoneBinds(curZone, bindError);
}
if(!bindError.BindErrors.empty())
throw bindError;
}
// ***************************************************************************
void CLandscape::checkBinds(uint16 zoneId) throw(EBadBind)
{
EBadBind bindError;
ItZoneMap it= Zones.find(zoneId);
if(it!= Zones.end())
{
CZone &curZone= *(*it).second;
checkZoneBinds(curZone, bindError);
if(!bindError.BindErrors.empty())
throw bindError;
}
}
// ***************************************************************************
void CLandscape::addTrianglesInBBox(const CPatchIdentEx &paIdEx, const CAABBox &bbox, std::vector<CTrianglePatch> &triangles, uint8 tileTessLevel) const
{
// No clear here, just add triangles to the array.
const CPatch *pa= paIdEx.Patch;
CPatchIdent paId;
paId.ZoneId= paIdEx.ZoneId;
paId.PatchId= paIdEx.PatchId;
pa->addTrianglesInBBox(paId, bbox, triangles, tileTessLevel);
}
// ***************************************************************************
void CLandscape::buildTrianglesInBBox(const CAABBox &bbox, std::vector<CTrianglePatch> &triangles, uint8 tileTessLevel)
{
// clear selection.
triangles.clear();
// search path of interest.
_PatchQuadGrid.clearSelection();
_PatchQuadGrid.select(bbox.getMin(), bbox.getMax());
CQuadGrid<CPatchIdentEx>::CIterator it;
// for each patch, add triangles to the array.
for(it= _PatchQuadGrid.begin(); it!= _PatchQuadGrid.end(); it++)
{
addTrianglesInBBox((*it), bbox, triangles, tileTessLevel);
}
}
// ***************************************************************************
void CLandscape::addPatchBlocksInBBox(const CPatchIdentEx &paIdEx, const CAABBox &bbox, std::vector<CPatchBlockIdent> &paBlockIds)
{
// No clear here, just add blocks to the array.
const CPatch *pa= paIdEx.Patch;
CPatchIdent paId;
paId.ZoneId= paIdEx.ZoneId;
paId.PatchId= paIdEx.PatchId;
pa->addPatchBlocksInBBox(paId, bbox, paBlockIds);
}
// ***************************************************************************
void CLandscape::buildPatchBlocksInBBox(const CAABBox &bbox, std::vector<CPatchBlockIdent> &paBlockIds)
{
// clear selection.
paBlockIds.clear();
// search path of interest.
_PatchQuadGrid.clearSelection();
_PatchQuadGrid.select(bbox.getMin(), bbox.getMax());
CQuadGrid<CPatchIdentEx>::CIterator it;
// for each patch, add blocks to the array.
for(it= _PatchQuadGrid.begin(); it!= _PatchQuadGrid.end(); it++)
{
addPatchBlocksInBBox((*it), bbox, paBlockIds);
}
}
// ***************************************************************************
void CLandscape::fillPatchQuadBlock(CPatchQuadBlock &quadBlock) const
{
sint zoneId= quadBlock.PatchBlockId.PatchId.ZoneId;
sint patchId= quadBlock.PatchBlockId.PatchId.PatchId;
std::map<uint16, CZone*>::const_iterator it= Zones.find(uint16(zoneId));
if(it!=Zones.end())
{
sint N= (*it).second->getNumPatchs();
// patch must exist in the zone.
nlassert(patchId>=0);
nlassert(patchId<N);
const CPatch *pa= const_cast<const CZone*>((*it).second)->getPatch(patchId);
pa->fillPatchQuadBlock(quadBlock);
}
}
// ***************************************************************************
void CLandscape::buildCollideFaces(const CAABBoxExt &bbox, vector<CTriangle> &faces, bool faceClip)
{
CBSphere bsWanted(bbox.getCenter(), bbox.getRadius());
faces.clear();
// For all zones.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
const CAABBoxExt &bb= (*it).second->getZoneBB();
CBSphere bs(bb.getCenter(), bb.getRadius());
// If zone intersect the wanted area.
//===================================
if(bs.intersect(bsWanted))
{
// Then trace all patch.
sint N= (*it).second->getNumPatchs();
for(sint i=0;i<N;i++)
{
const CPatch *pa= const_cast<const CZone*>((*it).second)->getPatch(i);
// If patch in wanted area....
//============================
if(bsWanted.intersect((*it).second->getPatchBSphere(i)))
{
// 0. Build the faces.
//====================
sint ordS= pa->getOrderS();
sint ordT= pa->getOrderT();
sint x,y,j;
vector<CTriangle> tmpFaces;
tmpFaces.reserve(ordS*ordT);
float OOS= 1.0f/ordS;
float OOT= 1.0f/ordT;
for(y=0;y<ordT;y++)
{
for(x=0;x<ordS;x++)
{
CTriangle f;
f.V0= pa->computeVertex(x*OOS, y*OOT);
f.V1= pa->computeVertex(x*OOS, (y+1)*OOT);
f.V2= pa->computeVertex((x+1)*OOS, (y+1)*OOT);
tmpFaces.push_back(f);
f.V0= pa->computeVertex(x*OOS, y*OOT);
f.V1= pa->computeVertex((x+1)*OOS, (y+1)*OOT);
f.V2= pa->computeVertex((x+1)*OOS, y*OOT);
tmpFaces.push_back(f);
}
}
// 1. Clip the faces.
//===================
if(faceClip)
{
// Insert only faces which are In the area.
for(j=0;j<(sint)tmpFaces.size();j++)
{
CTriangle &f= tmpFaces[j];
if(bbox.intersect(f.V0, f.V1, f.V2))
{
faces.push_back(f);
}
}
}
else
{
// Else insert ALL.
faces.insert(faces.end(), tmpFaces.begin(), tmpFaces.end());
}
}
}
}
}
}
// ***************************************************************************
void CLandscape::buildCollideFaces(sint zoneId, sint patch, std::vector<CTriangle> &faces)
{
faces.clear();
ItZoneMap it= Zones.find(uint16(zoneId));
if(it!=Zones.end())
{
// Then trace all patch.
sint N= (*it).second->getNumPatchs();
nlassert(patch>=0);
nlassert(patch<N);
const CPatch *pa= const_cast<const CZone*>((*it).second)->getPatch(patch);
// Build the faces.
//=================
sint ordS= pa->getOrderS();
sint ordT= pa->getOrderT();
sint x,y;
float OOS= 1.0f/ordS;
float OOT= 1.0f/ordT;
for(y=0;y<ordT;y++)
{
for(x=0;x<ordS;x++)
{
CTriangle f;
f.V0= pa->computeVertex(x*OOS, y*OOT);
f.V1= pa->computeVertex(x*OOS, (y+1)*OOT);
f.V2= pa->computeVertex((x+1)*OOS, (y+1)*OOT);
faces.push_back(f);
f.V0= pa->computeVertex(x*OOS, y*OOT);
f.V1= pa->computeVertex((x+1)*OOS, (y+1)*OOT);
f.V2= pa->computeVertex((x+1)*OOS, y*OOT);
faces.push_back(f);
}
}
}
}
// ***************************************************************************
CVector CLandscape::getTesselatedPos(const CPatchIdent &patchId, const CUV &uv) const
{
// First, must update globals, for CTessFace::computeTesselatedPos() to work properly.
// VertexProgrma mode???
CLandscapeGlobals::VertexProgramEnabled= _VertexShaderOk;
// If VertexProgram enabled
if( CLandscapeGlobals::VertexProgramEnabled )
{
/* because VertexProgram enabled, CTessVertex::Pos (geomorphed Pos) are not computed each frame
Hence, CTessFace::computeTesselatedPos() will call CTessVertex::computeGeomPos() to have correct
CTessVertex::Pos. ThereFore we must setup globals so CTessVertex::computeGeomPos() works properly.
*/
// see copy in updateGlobalsAndLockBuffers(). NB: Just copy what needed here!!!!
// Tile subdivsion part.
CLandscapeGlobals::TileDistNear = _TileDistNear;
CLandscapeGlobals::TileDistFar = CLandscapeGlobals::TileDistNear+20;
CLandscapeGlobals::TileDistNearSqr = sqr(CLandscapeGlobals::TileDistNear);
CLandscapeGlobals::TileDistFarSqr = sqr(CLandscapeGlobals::TileDistFar);
CLandscapeGlobals::OOTileDistDeltaSqr = 1.0f / (CLandscapeGlobals::TileDistFarSqr - CLandscapeGlobals::TileDistNearSqr);
// RefineThreshold.
CLandscapeGlobals::RefineThreshold= _Threshold;
CLandscapeGlobals::OORefineThreshold= 1.0f / CLandscapeGlobals::RefineThreshold;
// Refine Center*.
// NB: setup the last setuped refineCenter.
CLandscapeGlobals::RefineCenter= _OldRefineCenter;
}
// \todo yoyo: TODO_ZONEID: change ZoneId in 32 bits...
std::map<uint16, CZone*>::const_iterator it= Zones.find((uint16)patchId.ZoneId);
if(it!=Zones.end())
{
sint N= (*it).second->getNumPatchs();
// patch must exist in the zone.
nlassert(patchId.PatchId<N);
const CPatch *pa= const_cast<const CZone*>((*it).second)->getPatch(patchId.PatchId);
return pa->getTesselatedPos(uv);
}
else
return CVector::Null;
}
#define NL_TILE_FAR_SIZE_ORDER0 (NL_NUM_PIXELS_ON_FAR_TILE_EDGE*NL_NUM_PIXELS_ON_FAR_TILE_EDGE)
#define NL_TILE_FAR_SIZE_ORDER1 ((NL_NUM_PIXELS_ON_FAR_TILE_EDGE>>1)*(NL_NUM_PIXELS_ON_FAR_TILE_EDGE>>1))
#define NL_TILE_FAR_SIZE_ORDER2 ((NL_NUM_PIXELS_ON_FAR_TILE_EDGE>>2)*(NL_NUM_PIXELS_ON_FAR_TILE_EDGE>>2))
// ***************************************************************************
// internal use
bool CLandscape::eraseTileFarIfNotGood (uint tileNumber, uint sizeOrder0, uint sizeOrder1, uint sizeOrder2)
{
// The same tiles ?
bool bSame=true;
// It is the same tile ?
if (TileFarBank.getTile (tileNumber)->isFill (CTileFarBank::diffuse))
{
// Good diffuse size ?
if (
(TileFarBank.getTile (tileNumber)->getSize (CTileFarBank::diffuse, CTileFarBank::order0) != sizeOrder0) ||
(TileFarBank.getTile (tileNumber)->getSize (CTileFarBank::diffuse, CTileFarBank::order1) != sizeOrder1) ||
(TileFarBank.getTile (tileNumber)->getSize (CTileFarBank::diffuse, CTileFarBank::order2) != sizeOrder2)
)
{
TileFarBank.getTile (tileNumber)->erasePixels (CTileFarBank::diffuse);
bSame=false;
}
}
// It is the same tile ?
if (TileFarBank.getTile (tileNumber)->isFill (CTileFarBank::additive))
{
// Good additive size ?
if (
(TileFarBank.getTile (tileNumber)->getSize (CTileFarBank::additive, CTileFarBank::order0) != sizeOrder0) ||
(TileFarBank.getTile (tileNumber)->getSize (CTileFarBank::additive, CTileFarBank::order1) != sizeOrder1) ||
(TileFarBank.getTile (tileNumber)->getSize (CTileFarBank::additive, CTileFarBank::order2) != sizeOrder2)
)
{
TileFarBank.getTile (tileNumber)->erasePixels (CTileFarBank::additive);
bSame=false;
}
}
// Return true if the tiles seem to be the sames
return bSame;
}
// ***************************************************************************
bool CLandscape::initTileBanks ()
{
// *** Check the two banks are OK
_FarInitialized=false;
// Compatibility check
bool bCompatibility=true;
// Same number of tiles
if (TileBank.getTileCount()==TileFarBank.getNumTile())
{
// Same tileSet
for (int tileSet=0; tileSet<TileBank.getTileSetCount(); tileSet++)
{
// Same tile128
int tile;
for (tile=0; tile<TileBank.getTileSet(tileSet)->getNumTile128(); tile++)
{
// tile number
uint tileNumber=TileBank.getTileSet(tileSet)->getTile128(tile);
// erase the tiles if not good
bCompatibility&=eraseTileFarIfNotGood (tileNumber, NL_TILE_FAR_SIZE_ORDER0, NL_TILE_FAR_SIZE_ORDER1, NL_TILE_FAR_SIZE_ORDER2);
}
// Same tile256
for (tile=0; tile<TileBank.getTileSet(tileSet)->getNumTile256(); tile++)
{
// tile number
uint tileNumber=TileBank.getTileSet(tileSet)->getTile256(tile);
// erase the tiles if not good
bCompatibility&=eraseTileFarIfNotGood (tileNumber, NL_TILE_FAR_SIZE_ORDER0<<2, NL_TILE_FAR_SIZE_ORDER1<<2, NL_TILE_FAR_SIZE_ORDER2<<2);
}
// Same transition
for (tile=0; tile<CTileSet::count; tile++)
{
// tile number
uint tileNumber=TileBank.getTileSet(tileSet)->getTransition(tile)->getTile();
// erase the tiles if not good
bCompatibility&=eraseTileFarIfNotGood (tileNumber, NL_TILE_FAR_SIZE_ORDER0, NL_TILE_FAR_SIZE_ORDER1, NL_TILE_FAR_SIZE_ORDER2);
}
}
// Far actived!
_FarInitialized=true;
}
// Register / Load the vegetables.
TileBank.initTileVegetableDescs(_VegetableManager);
return bCompatibility;
}
// ***************************************************************************
void CLandscape::setupStaticLight (const CRGBA &diffuse, const CRGBA &ambiant, float multiply)
{
sint nMultiply=(sint)(256.f*multiply);
for (int i=0; i<256; i++)
{
sint max=0;
sint r=(((nMultiply*diffuse.R*i)>>8)+ambiant.R*(256-i))>>8;
if (r>max)
max=r;
sint g=(((nMultiply*diffuse.G*i)>>8)+ambiant.G*(256-i))>>8;
if (g>max)
max=g;
sint b=(((nMultiply*diffuse.B*i)>>8)+ambiant.B*(256-i))>>8;
if (b>max)
max=b;
// Not << 8 but << 7 because the _LightValue color table represent a ramp from 0 to 512
r <<= 7;
g <<= 7;
b <<= 7;
max=std::max(max, 256);
r/=max;
g/=max;
b/=max;
clamp (r, 0, 255);
clamp (g, 0, 255);
clamp (b, 0, 255);
_LightValue[i].R=uint8(r);
_LightValue[i].G=uint8(g);
_LightValue[i].B=uint8(b);
_LightValue[i].A=255;
}
}
// ***************************************************************************
void CLandscape::enableAutomaticLighting(bool enable)
{
_AutomaticLighting= enable;
}
// ***************************************************************************
void CLandscape::setupAutomaticLightDir(const CVector &lightDir)
{
_AutomaticLightDir= lightDir;
_AutomaticLightDir.normalize();
}
// ***************************************************************************
CVector CLandscape::getHeightFieldDeltaZ(float x, float y) const
{
if(_HeightField.ZPatchs.size()==0)
return CVector::Null;
// map to _HeightField coordinates.
x-= _HeightField.OriginX;
y-= _HeightField.OriginY;
x*= _HeightField.OOSizeX;
y*= _HeightField.OOSizeY;
// get patch on the grid.
sint ix, iy;
ix= (sint)floor(x);
iy= (sint)floor(y);
// out of the grid?
if( ix<0 || ix>=(sint)_HeightField.Width || iy<0 || iy>=(sint)_HeightField.Height)
return CVector::Null;
// get patch.
const CBezierPatchZ &paz= _HeightField.ZPatchs[iy*_HeightField.Width + ix];
// compute result.
CVector ret=CVector::Null;
ret.x= 0;
ret.y= 0;
ret.z= paz.eval(x-ix, y-iy);
return ret;
}
// ***************************************************************************
void CLandscape::CBezierPatchZ::makeInteriors()
{
float &a = Vertices[0];
float &b = Vertices[1];
float &c = Vertices[2];
float &d = Vertices[3];
Interiors[0] = Tangents[7] + Tangents[0] - a;
Interiors[1] = Tangents[1] + Tangents[2] - b;
Interiors[2] = Tangents[3] + Tangents[4] - c;
Interiors[3] = Tangents[5] + Tangents[6] - d;
}
// ***************************************************************************
float CLandscape::CBezierPatchZ::eval(float ps, float pt) const
{
float p;
float ps2 = ps * ps;
float ps1 = 1.0f - ps;
float ps12 = ps1 * ps1;
float s0 = ps12 * ps1;
float s1 = 3.0f * ps * ps12;
float s2 = 3.0f * ps2 * ps1;
float s3 = ps2 * ps;
float pt2 = pt * pt;
float pt1 = 1.0f - pt;
float pt12 = pt1 * pt1;
float t0 = pt12 * pt1;
float t1 = 3.0f * pt * pt12;
float t2 = 3.0f * pt2 * pt1;
float t3 = pt2 * pt;
p = Vertices[0] * s0 * t0 +
Tangents[7] * s1 * t0 +
Tangents[6] * s2 * t0 +
Vertices[3] * s3 * t0;
p+= Tangents[0] * s0 * t1 +
Interiors[0]* s1 * t1 +
Interiors[3]* s2 * t1 +
Tangents[5] * s3 * t1;
p+= Tangents[1] * s0 * t2 +
Interiors[1]* s1 * t2 +
Interiors[2]* s2 * t2 +
Tangents[4] * s3 * t2;
p+= Vertices[1] * s0 * t3 +
Tangents[2] * s1 * t3 +
Tangents[3] * s2 * t3 +
Vertices[2] * s3 * t3;
return p;
}
// ***************************************************************************
void CLandscape::setHeightField(const CHeightMap &hf)
{
if(hf.getWidth()<2)
return;
if(hf.getHeight()<2)
return;
// Fill basics.
_HeightField.OriginX= hf.OriginX;
_HeightField.OriginY= hf.OriginY;
_HeightField.SizeX= hf.SizeX;
_HeightField.SizeY= hf.SizeY;
_HeightField.OOSizeX= 1/hf.SizeX;
_HeightField.OOSizeY= 1/hf.SizeY;
uint w= hf.getWidth()-1;
uint h= hf.getHeight()-1;
_HeightField.Width= w;
_HeightField.Height= h;
_HeightField.ZPatchs.resize(w * h);
// compute patchs
sint x,y;
// compute vertices / tangents on each patch
for(y=0;y<(sint)h;y++)
{
for(x=0;x<(sint)w;x++)
{
CBezierPatchZ &paz= _HeightField.ZPatchs[y*w+x];
// vertices.
paz.Vertices[0]= hf.getZ(x, y);
paz.Vertices[1]= hf.getZ(x, y+1);
paz.Vertices[2]= hf.getZ(x+1, y+1);
paz.Vertices[3]= hf.getZ(x+1, y);
}
}
// compute tangents
for(y=0;y<(sint)h;y++)
{
for(x=0;x<(sint)w;x++)
{
CBezierPatchZ &paz= _HeightField.ZPatchs[y*w+x];
sint tg;
// For each tangent, what vertex (relative to x,y) we must take.
struct CDeltaPos
{
sint ox,oy;
sint dx1,dy1;
sint dx2,dy2;
};
static CDeltaPos deltas[8]= {
{0,0, 0,1, 0,-1} ,
{0,1, 0,0, 0,2} ,
{0,1, 1,1, -1,1} ,
{1,1, 0,1, 2,1} ,
{1,1, 1,0, 1,2} ,
{1,0, 1,1, 1,-1} ,
{1,0, 0,0, 2,0} ,
{0,0, 1,0, -1,0} ,
};
// compute each tangent of this patch.
for(tg=0; tg<8;tg++)
{
sint x0,y0;
sint x1,y1;
sint x2,y2;
x0= x+deltas[tg].ox; y0= y+deltas[tg].oy;
x1= x+deltas[tg].dx1; y1= y+deltas[tg].dy1;
x2= x+deltas[tg].dx2; y2= y+deltas[tg].dy2;
// borders case.
if(x2<0 || x2>=(sint)hf.getWidth() || y2<0 || y2>=(sint)hf.getHeight())
{
float v,dv;
// base of tangents.
v= hf.getZ(x0,y0);
// target tangents.
dv= hf.getZ(x1,y1) - v;
// result of tangent.
paz.Tangents[tg]= v+dv/3;
}
// middle case.
else
{
float v,dv;
// base of tangents.
v= hf.getZ(x0,y0);
// target tangents.
dv= hf.getZ(x1,y1) - v;
// add mirror target tangent.
dv+= -(hf.getZ(x2,y2) - v);
dv/=2;
// result of tangent.
paz.Tangents[tg]= v+dv/3;
}
}
}
}
// compute interiors.
for(y=0;y<(sint)h;y++)
{
for(x=0;x<(sint)w;x++)
{
CBezierPatchZ &paz= _HeightField.ZPatchs[y*w+x];
paz.makeInteriors();
}
}
}
// ***************************************************************************
void CLandscape::getTessellationLeaves(std::vector<const CTessFace*> &leaves) const
{
leaves.clear();
std::map<uint16, CZone*>::const_iterator it;
for(it= Zones.begin();it!=Zones.end();it++)
{
// Then trace all patch.
sint N= (*it).second->getNumPatchs();
for(sint i=0;i<N;i++)
{
const CPatch *pa= const_cast<const CZone*>((*it).second)->getPatch(i);
pa->appendTessellationLeaves(leaves);
}
}
}
// ***************************************************************************
void CLandscape::setPZBModelPosition(const CVector &pos)
{
_PZBModelPosition= pos;
}
// ***************************************************************************
class CTextureFarLevelInfo
{
public:
uint NumUsedPatchs;
uint NumTextures;
CTextureFarLevelInfo()
{
NumUsedPatchs= 0;
NumTextures= 0;
}
};
void CLandscape::profileRender()
{
// TODO yoyo: new Far mgt profile
/*
std::map<CVector2f, CTextureFarLevelInfo > levelFarMap;
nlinfo("***** Landscape TextureFar Profile. NumTextureFar= %d", _TextureFars.size());
// Profile Texture Allocate
ItSPRenderPassVector itFar;
uint totalMemUsage= 0;
for(itFar= _TextureFars.begin(); itFar!= _TextureFars.end(); itFar++)
{
CPatchRdrPass &pass= **itFar;
CTextureFar *textureFar= safe_cast<CTextureFar*>((ITexture*)pass.TextureDiffuse);
// Info
uint memUsage= textureFar->getPatchWidth()*textureFar->getPatchHeight()*NL_NUM_FAR_PATCHES_BY_TEXTURE*2;
nlinfo(" * Patch Texture Size: (%d,%d) => :%d bytes for %d patchs",
textureFar->getPatchWidth(), textureFar->getPatchHeight(),
memUsage, NL_NUM_FAR_PATCHES_BY_TEXTURE);
totalMemUsage+= memUsage;
// Profile Texture Far Allocated
nlinfo(" * NumberOf Patch in the texture:%d", textureFar->getPatchCount());
// Profile currently used Patchs
uint numRdrPatch= 0;
CPatch *pa= pass.getRdrPatchFar0();
while(pa)
{
numRdrPatch++;
pa= pa->getNextFar0ToRdr();
}
pa= pass.getRdrPatchFar1();
while(pa)
{
numRdrPatch++;
pa= pa->getNextFar1ToRdr();
}
nlinfo(" * NumberOf Patch in frustum for this texture (Far0+Far1):%d", numRdrPatch);
// regroup by level
CVector2f sizeLevel;
sizeLevel.x= (float)textureFar->getPatchWidth();
sizeLevel.y= (float)textureFar->getPatchHeight();
levelFarMap[sizeLevel].NumUsedPatchs+= textureFar->getPatchCount();
levelFarMap[sizeLevel].NumTextures++;
}
nlinfo("***** Landscape TextureFar Level Profile. TotalVideoMemory= %d", totalMemUsage);
std::map<CVector2f, CTextureFarLevelInfo >::iterator itLevelFar= levelFarMap.begin();
while(itLevelFar!=levelFarMap.end())
{
nlinfo(" * Level PatchSize: (%d, %d). Total NumberOf Patch: %d. Use Percentage: %d %%",
(uint)itLevelFar->first.x, (uint)itLevelFar->first.y, itLevelFar->second.NumUsedPatchs,
100*itLevelFar->second.NumUsedPatchs/(itLevelFar->second.NumTextures*NL_NUM_FAR_PATCHES_BY_TEXTURE) );
itLevelFar++;
}
*/
}
// ***************************************************************************
// ***************************************************************************
// Allocators.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CTessFace *CLandscape::newTessFace()
{
// allcoate the face.
CTessFace *face= TessFaceAllocator.allocate();
// for refine() mgt, append the face to the list of newLeaves, so they will be tested in refine()
face->linkInPList(_RootNewLeaves);
return face;
}
// ***************************************************************************
CTessVertex *CLandscape::newTessVertex()
{
return TessVertexAllocator.allocate();
}
// ***************************************************************************
CTessNearVertex *CLandscape::newTessNearVertex()
{
return TessNearVertexAllocator.allocate();
}
// ***************************************************************************
CTessFarVertex *CLandscape::newTessFarVertex()
{
return TessFarVertexAllocator.allocate();
}
// ***************************************************************************
CTileMaterial *CLandscape::newTileMaterial()
{
return TileMaterialAllocator.allocate();
}
// ***************************************************************************
CTileFace *CLandscape::newTileFace()
{
return TileFaceAllocator.allocate();
}
// ***************************************************************************
void CLandscape::deleteTessFace(CTessFace *f)
{
// for refine() mgt, must remove from refine priority list, or from the temp rootTessFaceToUpdate list.
f->unlinkInPList();
TessFaceAllocator.free(f);
}
// ***************************************************************************
void CLandscape::deleteTessVertex(CTessVertex *v)
{
TessVertexAllocator.free(v);
}
// ***************************************************************************
void CLandscape::deleteTessNearVertex(CTessNearVertex *v)
{
TessNearVertexAllocator.free(v);
}
// ***************************************************************************
void CLandscape::deleteTessFarVertex(CTessFarVertex *v)
{
TessFarVertexAllocator.free(v);
}
// ***************************************************************************
void CLandscape::deleteTileMaterial(CTileMaterial *tm)
{
TileMaterialAllocator.free(tm);
}
// ***************************************************************************
void CLandscape::deleteTileFace(CTileFace *tf)
{
TileFaceAllocator.free(tf);
}
// ***************************************************************************
// ***************************************************************************
// Noise
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CLandscape::setNoiseMode(bool enable)
{
_NoiseEnabled= enable;
}
// ***************************************************************************
bool CLandscape::getNoiseMode() const
{
return _NoiseEnabled;
}
// ***************************************************************************
// ***************************************************************************
// Micro vegetation
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CLandscape::enableVegetable(bool enable)
{
_VegetableManagerEnabled= enable;
// if false, delete all Vegetable IGs.
if(!_VegetableManagerEnabled)
{
// Landscape always create ClipBlokcs, but IGs/addInstances() are created only if isVegetableActive().
// For all zones.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
// for all patch.
sint N= (*it).second->getNumPatchs();
for(sint i=0;i<N;i++)
{
// delete vegetable Igs of this patch
CPatch *pa= ((*it).second)->getPatch(i);
pa->deleteAllVegetableIgs();
}
}
}
// if true
else
{
// reload all Shapes (actually load only new shapes)
TileBank.initTileVegetableDescs(_VegetableManager);
// And recreate vegetable igs.
// Landscape always create ClipBlokcs, but IGs/addInstances() are created only if isVegetableActive().
// For all zones.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
// for all patch.
sint N= (*it).second->getNumPatchs();
for(sint i=0;i<N;i++)
{
// recreate vegetable Igs of this patch
CPatch *pa= ((*it).second)->getPatch(i);
pa->recreateAllVegetableIgs();
}
}
}
}
// ***************************************************************************
bool CLandscape::isVegetableActive() const
{
return _VegetableManagerEnabled && _DriverOkForVegetable;
}
// ***************************************************************************
void CLandscape::loadVegetableTexture(const string &textureFileName)
{
// load the texture in the manager
_VegetableManager->loadTexture(textureFileName);
}
// ***************************************************************************
void CLandscape::setupVegetableLighting(const CRGBA &ambient, const CRGBA &diffuse, const CVector &directionalLight)
{
// set the directional light to the manager
_VegetableManager->setDirectionalLight(ambient, diffuse, directionalLight);
}
// ***************************************************************************
void CLandscape::setVegetableWind(const CVector &windDir, float windFreq, float windPower, float windBendMin)
{
// setup vegetable manager
_VegetableManager->setWind(windDir, windFreq, windPower, windBendMin);
}
// ***************************************************************************
void CLandscape::setVegetableTime(double time)
{
// setup vegetable manager
_VegetableManager->setTime(time);
}
// ***************************************************************************
void CLandscape::setVegetableUpdateLightingTime(double time)
{
// setup vegetable manager
_VegetableManager->setUpdateLightingTime(time);
}
// ***************************************************************************
uint CLandscape::getNumVegetableFaceRendered() const
{
return _VegetableManager->getNumVegetableFaceRendered();
}
// ***************************************************************************
const CTileVegetableDesc &CLandscape::getTileVegetableDesc(uint16 tileId)
{
return TileBank.getTileVegetableDesc(tileId);
}
// ***************************************************************************
void CLandscape::createVegetableBlendLayersModels(CScene *scene)
{
_VegetableManager->createVegetableBlendLayersModels(scene);
}
// ***************************************************************************
void CLandscape::setVegetableUpdateLightingFrequency(float freq)
{
_VegetableManager->setUpdateLightingFrequency(freq);
}
// ***************************************************************************
void CLandscape::setupColorsFromTileFlags(const NLMISC::CRGBA colors[4])
{
for (TZoneMap::iterator it = Zones.begin(); it != Zones.end(); ++it)
{
it->second->setupColorsFromTileFlags(colors);
}
}
// ***************************************************************************
void CLandscape::setVegetableDensity(float density)
{
// if the density is really different from what actually setuped
if(density!=_VegetableManager->getGlobalDensity())
{
_VegetableManager->setGlobalDensity(density);
// must recreate all vegetables IGs
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
// for all patch.
sint N= (*it).second->getNumPatchs();
for(sint i=0;i<N;i++)
{
// delete vegetable Igs of this patch
CPatch *pa= ((*it).second)->getPatch(i);
pa->deleteAllVegetableIgs();
// then recreate vegetable Igs of this patch
pa->recreateAllVegetableIgs();
}
}
}
}
// ***************************************************************************
float CLandscape::getVegetableDensity() const
{
return _VegetableManager->getGlobalDensity();
}
// ***************************************************************************
// ***************************************************************************
// Lightmap Get interface.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
uint8 CLandscape::getLumel(const CPatchIdent &patchId, const CUV &uv) const
{
// \todo yoyo: TODO_ZONEID: change ZoneId in 32 bits...
std::map<uint16, CZone*>::const_iterator it= Zones.find((uint16)patchId.ZoneId);
if(it!=Zones.end())
{
sint N= (*it).second->getNumPatchs();
// patch must exist in the zone.
nlassert(patchId.PatchId<N);
const CPatch *pa= const_cast<const CZone*>((*it).second)->getPatch(patchId.PatchId);
return pa->getLumel(uv);
}
else
// Return full sun contribution as default
return 255;
}
// ***************************************************************************
void CLandscape::appendTileLightInfluences(const CPatchIdent &patchId, const CUV &uv,
std::vector<CPointLightInfluence> &pointLightList) const
{
// \todo yoyo: TODO_ZONEID: change ZoneId in 32 bits...
std::map<uint16, CZone*>::const_iterator it= Zones.find((uint16)patchId.ZoneId);
if(it!=Zones.end())
{
sint N= (*it).second->getNumPatchs();
// patch must exist in the zone.
nlassert(patchId.PatchId<N);
const CPatch *pa= const_cast<const CZone*>((*it).second)->getPatch(patchId.PatchId);
pa->appendTileLightInfluences(uv, pointLightList);
}
}
// ***************************************************************************
// ***************************************************************************
// Lighting
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CLandscape::removeAllPointLights()
{
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
// for all patch.
sint N= (*it).second->getNumPatchs();
for(sint i=0;i<N;i++)
{
// Clear TileLightInfluences
CPatch *pa= ((*it).second)->getPatch(i);
pa->resetTileLightInfluences();
}
// Remove all PointLights.
(*it).second->_PointLightArray.clear();
}
}
// ***************************************************************************
void CLandscape::setPointLightFactor(const CScene &scene)
{
// Affect currently added zones.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
(*it).second->_PointLightArray.setPointLightFactor(scene);
}
}
// ***************************************************************************
void CLandscape::updateLighting(double time)
{
_ULTime= time;
// first time in this method??
if(!_ULPrecTimeInit)
{
_ULPrecTimeInit= true;
_ULPrecTime= _ULTime;
}
// compute delta time from last update.
float dt= float(_ULTime - _ULPrecTime);
_ULPrecTime= _ULTime;
// If not disabled
if(_ULFrequency)
{
// Do it for near and far in 2 distinct ways.
updateLightingTextureFar(dt * _ULFrequency);
updateLightingTextureNear(dt * _ULFrequency);
}
}
// ***************************************************************************
void CLandscape::updateLightingAll()
{
// Do it for near and far in 2 distinct ways.
//================
updateLightingTextureFar(1);
updateLightingTextureNear(1);
// update lighting for vegetables
//================
// Must lock buffers for update Lighting of vegetables.
updateGlobalsAndLockBuffers (CVector::Null);
// Because updateLighting() may use OptFastFloor..
NLMISC::OptFastFloorBegin();
// update ALL lighting for vegetables
_VegetableManager->updateLightingAll();
// Stop fastFloor optim.
NLMISC::OptFastFloorEnd();
// Must realase VB Buffers
unlockBuffers();
}
// ***************************************************************************
void CLandscape::setUpdateLightingFrequency(float freq)
{
freq= max(freq, 0.f);
_ULFrequency= freq;
}
// ***************************************************************************
void CLandscape::linkPatchToNearUL(CPatch *patch)
{
// Append this patch to the list of patch to updateLighting.
if(_ULRootNearPatch==NULL)
_ULRootNearPatch= patch;
else
patch->linkBeforeNearUL(_ULRootNearPatch);
}
// ***************************************************************************
void CLandscape::unlinkPatchFromNearUL(CPatch *patch)
{
// If I unlink the patch which is the current root
if(_ULRootNearPatch==patch)
{
// switch to next
_ULRootNearPatch= patch->getNextNearUL();
// if still the same, it means that the circular list is now empty
if(_ULRootNearPatch==patch)
_ULRootNearPatch= NULL;
// reset tessBlock counter.
_ULNearCurrentTessBlockId= 0;
}
// unlink the patch from list
patch->unlinkNearUL();
}
// ***************************************************************************
void CLandscape::updateLightingTextureFar(float ratio)
{
// compute number of pixels to update.
_ULFarPixelsToUpdate+= ratio * _ULTotalFarPixels;
// maximize, so at max, it computes all patchs, just one time.
_ULFarPixelsToUpdate= min(_ULFarPixelsToUpdate, (float)_ULTotalFarPixels);
// Test Profile Yoyo
/*extern bool YOYO_LandULTest;
if(YOYO_LandULTest)
{
nlinfo("YOYO_UL Far: %dK, %dK", (sint)_ULFarPixelsToUpdate/1024, (sint)_ULTotalFarPixels/1024);
}*/
// while there is still some pixels to update.
while(_ULFarPixelsToUpdate > 0 && _ULRootTextureFar)
{
// update patch (if not null) in the textureFar.
_ULFarPixelsToUpdate-= _ULRootTextureFar->touchPatchULAndNext();
// last patch in the texture??
if( _ULRootTextureFar->endPatchULTouch() )
{
// yes, go to next texture.
_ULRootTextureFar= _ULRootTextureFar->getNextUL();
// reset to 0th patch.
_ULRootTextureFar->startPatchULTouch();
}
}
// Now, _ULFarPixelsToUpdate should be <=0. (most of the time < 0)
}
// ***************************************************************************
void CLandscape::updateLightingTextureNear(float ratio)
{
// compute number of pixels to update.
_ULNearPixelsToUpdate+= ratio * _ULTotalNearPixels;
// maximize, so at max, it computes all patchs, just one time.
_ULNearPixelsToUpdate= min(_ULNearPixelsToUpdate, (float)_ULTotalNearPixels);
// while there is still some pixels to update.
while(_ULNearPixelsToUpdate > 0 && _ULRootNearPatch)
{
// update tessBlock (if lightmap exist for this tessBlock) in the patch.
_ULNearPixelsToUpdate-= _ULRootNearPatch->updateTessBlockLighting(_ULNearCurrentTessBlockId);
// Next tessBlock to process.
_ULNearCurrentTessBlockId++;
// last tessBlock in the patch??
if(_ULNearCurrentTessBlockId>=_ULRootNearPatch->getNumNearTessBlocks())
{
// yes, go to next patch.
_ULRootNearPatch= _ULRootNearPatch->getNextNearUL();
// reset to 0th tessBlock.
_ULNearCurrentTessBlockId=0;
}
}
}
// ***************************************************************************
void CLandscape::computeDynamicLighting(const std::vector<CPointLight*> &pls)
{
uint i;
// Update globals, and lock buffers
//====================
updateGlobalsAndLockBuffers (CVector::Null);
// NB: averageTesselationVertices may change vertices in VB in visible patchs => buffers are locked.
// Run all DLM Context create, to init Lighting process.
//===============
CPatchDLMContext *ctxPtr= _PatchDLMContextList->begin();
while(ctxPtr!=NULL)
{
// init lighting process, do differential from last computeDynamicLighting()
ctxPtr->getPatch()->beginDLMLighting();
// next
ctxPtr= (CPatchDLMContext*)ctxPtr->Next;
}
// compile all pointLights
//===============
static vector<CPatchDLMPointLight> dlmPls;
dlmPls.resize(pls.size());
for(i=0;i<dlmPls.size();i++)
{
// compile the pl.
dlmPls[i].compile(*pls[i], _PointLightDiffuseMaterial, _DLMMaxAttEnd);
}
// For all pointLight, intersect patch.
//===============
for(i=0;i<dlmPls.size();i++)
{
CPatchDLMPointLight &pl= dlmPls[i];
// search patchs of interest: those which interssect the pointLight
_PatchQuadGrid.clearSelection();
_PatchQuadGrid.select(pl.BBox.getMin(), pl.BBox.getMax());
CQuadGrid<CPatchIdentEx>::CIterator it;
// for each patch, light it with the light.
for(it= _PatchQuadGrid.begin(); it!= _PatchQuadGrid.end(); it++)
{
// get the patch
const CPatch *pa= (*it).Patch;
// More precise clipping:
if( pa->getZone()->getPatchBSphere(pa->getPatchId()).intersect( pl.BSphere ) )
{
// Ok, light the patch with this spotLight
const_cast<CPatch*>(pa)->processDLMLight(pl);
}
}
}
// Run all DLM Context create, to end Lighting process.
//===============
ctxPtr= _PatchDLMContextList->begin();
while(ctxPtr!=NULL)
{
// get enxt now, because the DLM itself may be deleted in endDLMLighting()
CPatchDLMContext *next= (CPatchDLMContext*)ctxPtr->Next;
// delete the DLM if no more needed (near don't use nor pointLights)
ctxPtr->getPatch()->endDLMLighting();
// next
ctxPtr= next;
}
// Must realase VB Buffers
//====================
unlockBuffers();
}
// ***************************************************************************
void CLandscape::setDynamicLightingMaxAttEnd(float maxAttEnd)
{
maxAttEnd= max(maxAttEnd, 1.f);
_DLMMaxAttEnd= maxAttEnd;
}
// ***************************************************************************
uint CLandscape::getDynamicLightingMemoryLoad() const
{
uint mem= 0;
// First, set size of global texture overhead.
mem= NL3D_LANDSCAPE_DLM_WIDTH * NL3D_LANDSCAPE_DLM_HEIGHT * sizeof(CRGBA);
// Then, for each patchContext created
CPatchDLMContext *ctxPtr= _PatchDLMContextList->begin();
while(ctxPtr!=NULL)
{
// add its memory load.
mem+= ctxPtr->getMemorySize();
// next
ctxPtr= (CPatchDLMContext*)ctxPtr->Next;
}
return mem;
}
// ***************************************************************************
void CLandscape::setDLMGlobalVegetableColor(CRGBA gvc)
{
_DLMGlobalVegetableColor= gvc;
}
// ***************************************************************************
void CLandscape::setPointLightDiffuseMaterial(CRGBA diffuse)
{
_PointLightDiffuseMaterial= diffuse;
}
// ***************************************************************************
void CLandscape::initAnimatedLightIndex(const CScene &scene)
{
// Affect currently added zones.
for(ItZoneMap it= Zones.begin();it!=Zones.end();it++)
{
(*it).second->_PointLightArray.initAnimatedLightIndex(scene);
}
}
// ***************************************************************************
void CLandscape::releaseAllTiles()
{
nlassert(Zones.empty());
releaseTiles (0, TileInfos.size());
}
// ***************************************************************************
// ***************************************************************************
// Dynamic ShadowMaping
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CLandscape::appendToShadowPolyReceiver(CTessFace *face)
{
CTriangle tri;
tri.V0= face->VBase->EndPos;
tri.V1= face->VLeft->EndPos;
tri.V2= face->VRight->EndPos;
// Add and store id for remove
face->ShadowMapTriId= _ShadowPolyReceiver.addTriangle(tri);
}
// ***************************************************************************
void CLandscape::removeFromShadowPolyReceiver(CTessFace *face)
{
if(face->ShadowMapTriId!=-1)
{
_ShadowPolyReceiver.removeTriangle(face->ShadowMapTriId);
// set NULL Id.
face->ShadowMapTriId=-1;
}
}
// ***************************************************************************
void CLandscape::receiveShadowMap(IDriver *drv, CShadowMap *shadowMap, const CVector &casterPos, const CMaterial &shadowMat, const CVector &pzb)
{
/* substract the PZB from all coordinates.
Must add a small zbias because
The rendered Triangles may be computed with VertexProgram, but _ShadowPolyReceiver
does not. => there is a small float difference at the end
Even if same vertex is produced in theory, VertexProgram may cause 2 precision problems:
1/ On NVidia, even with a simple matrix mul VP, the precision result is not the same
2/ Our Landscape VP is not a simple matrix mul. Lot of vertex mul/add are done fpr geomorphs
*/
CMaterial &sm= const_cast<CMaterial&>(shadowMat);
float oldZBias= sm.getZBias();
sm.setZBias(-0.02f);
_ShadowPolyReceiver.render(drv, sm, shadowMap, casterPos, -pzb);
sm.setZBias(oldZBias);
}
// ***************************************************************************
void CLandscape::setZFunc(CMaterial::ZFunc val)
{
TileMaterial.setZFunc(val);
FarMaterial.setZFunc(val);
}
// ***************************************************************************
void CLandscape::invalidateAllTiles()
{
updateGlobalsAndLockBuffers(CVector::Null);
for(TZoneMap::iterator it = Zones.begin(); it != Zones.end(); ++it)
{
if (it->second->Compiled)
{
for(uint k = 0; k < it->second->Patchs.size(); ++k)
{
it->second->Patchs[k].deleteTileUvs();
it->second->Patchs[k].recreateTileUvs();
}
}
}
unlockBuffers();
updateTessBlocksFaceVector();
}
// ***************************************************************************
float CLandscape::getCameraCollision(const CVector &start, const CVector &end, float radius, bool cone)
{
return _ShadowPolyReceiver.getCameraCollision(start, end,
cone?CShadowPolyReceiver::CameraColCone:CShadowPolyReceiver::CameraColCylinder, radius);
}
// ***************************************************************************
float CLandscape::getRayCollision(const CVector &start, const CVector &end)
{
return _ShadowPolyReceiver.getCameraCollision(start, end,
CShadowPolyReceiver::CameraColSimpleRay, 0.f);
}
// ***************************************************************************
bool CLandscape::isTileCallback(ULandscapeTileCallback *cb) const
{
return std::find(_TileCallbacks.begin(), _TileCallbacks.end(), cb) != _TileCallbacks.end();
}
// ***************************************************************************
void CLandscape::addTileCallback(ULandscapeTileCallback *cb)
{
nlassert(cb);
nlassert(!isTileCallback(cb)); // callback added twice
_TileCallbacks.push_back(cb);
}
// ***************************************************************************
void CLandscape::removeTileCallback(ULandscapeTileCallback *cb)
{
nlassert(cb);
std::vector<ULandscapeTileCallback *>::iterator it = std::find(_TileCallbacks.begin(), _TileCallbacks.end(), cb);
nlassert(it != _TileCallbacks.end());
_TileCallbacks.erase(it);
}
} // NL3D
Reference in a new issue Copy permalink