mirror of
https://port.numenaute.org/aleajactaest/khanat-opennel-code.git
synced 2024-11-18 21:26:12 +00:00
3952 lines
122 KiB
C++
3952 lines
122 KiB
C++
// 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= (sint)_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, (uint32)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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|