aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-22 00:48:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/nel/src/3d/scene.cpp

1681 lines
47 KiB
C++
Raw Blame History

// 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/scene.h"
#include "nel/3d/trav_scene.h"
#include "nel/3d/hrc_trav.h"
#include "nel/3d/clip_trav.h"
#include "nel/3d/light_trav.h"
#include "nel/3d/anim_detail_trav.h"
#include "nel/3d/load_balancing_trav.h"
#include "nel/3d/render_trav.h"
#include "nel/3d/transform.h"
#include "nel/3d/camera.h"
#include "nel/3d/landscape_model.h"
#include "nel/3d/driver.h"
#include "nel/3d/transform_shape.h"
#include "nel/3d/mesh_base.h"
#include "nel/3d/mesh_base_instance.h"
#include "nel/3d/mesh_instance.h"
#include "nel/3d/mesh_mrm_instance.h"
#include "nel/3d/mesh_mrm_skinned_instance.h"
#include "nel/3d/mesh_multi_lod_instance.h"
#include "nel/3d/shape_bank.h"
#include "nel/3d/skeleton_model.h"
#include "nel/3d/particle_system_model.h"
#include "nel/3d/coarse_mesh_manager.h"
#include "nel/3d/cluster.h"
#include "nel/3d/scene_group.h"
#include "nel/3d/flare_model.h"
#include "nel/3d/water_model.h"
#include "nel/3d/vegetable_blend_layer_model.h"
#include "nel/3d/root_model.h"
#include "nel/3d/point_light_model.h"
#include "nel/3d/animation.h"
#include "nel/3d/lod_character_manager.h"
#include "nel/3d/seg_remanence.h"
#include "nel/3d/async_texture_manager.h"
#include "nel/3d/water_env_map.h"
#include "nel/3d/skeleton_spawn_script.h"
#include <memory>
#include "nel/misc/time_nl.h"
#include "nel/misc/file.h"
#include "nel/misc/path.h"
//
#include "nel/misc/system_info.h"
using namespace std;
using namespace NLMISC;
#define NL3D_SCENE_COARSE_MANAGER_TEXTURE "nel_coarse_texture.tga"
// The manager is limited to a square of 3000m*3000m around the camera. Beyond, models are clipped individually (bad!!).
const float NL3D_QuadGridClipManagerRadiusMax= 1500;
const float NL3D_QuadGridClipClusterSize= 400;
const uint NL3D_QuadGridClipNumDist= 10;
const float NL3D_QuadGridClipMaxDist= 1000;
#define NL3D_SCENE_DEFAULT_SHADOW_MAP_SIZE 64
#define NL3D_SCENE_DEFAULT_SHADOW_MAP_BLUR_SIZE 2
#define NL3D_SCENE_DEFAULT_SHADOW_MAP_DIST_FADE_START 40
#define NL3D_SCENE_DEFAULT_SHADOW_MAP_DIST_FADE_END 50
#define NL3D_SCENE_DEFAULT_SHADOW_MAP_MAX_CASTER_IN_SCREEN 16
#define NL3D_SCENE_DEFAULT_SHADOW_MAP_MAX_CASTER_AROUND 64
namespace NL3D
{
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CScene::registerBasics()
{
CTransform::registerBasic();
CCamera::registerBasic();
CMeshBaseInstance::registerBasic();
CMeshInstance::registerBasic();
CMeshMRMInstance::registerBasic();
CMeshMRMSkinnedInstance::registerBasic();
CLandscapeModel::registerBasic();
CTransformShape::registerBasic();
CSkeletonModel::registerBasic();
CParticleSystemModel::registerBasic() ;
CMeshMultiLodInstance::registerBasic();
CCluster::registerBasic();
CFlareModel::registerBasic();
CWaterModel::registerBasic();
CWaveMakerModel::registerBasic();
CVegetableBlendLayerModel::registerBasic();
CRootModel::registerBasic();
CPointLightModel::registerBasic();
CSegRemanence::registerBasic();
CQuadGridClipManager::registerBasic();
}
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CScene::CScene(bool bSmallScene) : LightTrav(bSmallScene)
{
HrcTrav.Scene= this;
ClipTrav.Scene= this;
LightTrav.Scene= this;
AnimDetailTrav.Scene= this;
LoadBalancingTrav.Scene= this;
RenderTrav.Scene= this;
_ShapeBank = NULL;
Root= NULL;
RootCluster= NULL;
SonsOfAncestorSkeletonModelGroup= NULL;
_QuadGridClipManager= NULL;
_CurrentTime = 0 ;
_EllapsedTime = 0 ;
_RealTime = 0 ;
_FirstAnimateCall = true ;
_LightingSystemEnabled= false;
_CoarseMeshLightingUpdate= 50;
_GlobalWindDirection.set(1,0,0);
// Default as Sithikt wants.
_GlobalWindPower= 0.2f;
// global manager (created in CDriverUser)
_LodCharacterManager= NULL;
_AsyncTextureManager= NULL;
_NumRender = 0;
_MaxSkeletonsInNotCLodForm= 20;
_FilterRenderFlags= std::numeric_limits<uint32>::max();
_NextRenderProfile= false;
// Init default _CoarseMeshManager
_CoarseMeshManager= new CCoarseMeshManager;
_CoarseMeshManager->setTextureFile (NL3D_SCENE_COARSE_MANAGER_TEXTURE);
// Update model list to NULL
_UpdateModelList= NULL;
_FlareContext = 0;
_ShadowMapTextureSize= NL3D_SCENE_DEFAULT_SHADOW_MAP_SIZE;
_ShadowMapBlurSize= NL3D_SCENE_DEFAULT_SHADOW_MAP_BLUR_SIZE;
_ShadowMapDistFadeStart= NL3D_SCENE_DEFAULT_SHADOW_MAP_DIST_FADE_START;
_ShadowMapDistFadeEnd= NL3D_SCENE_DEFAULT_SHADOW_MAP_DIST_FADE_END;
_ShadowMapMaxCasterInScreen= NL3D_SCENE_DEFAULT_SHADOW_MAP_MAX_CASTER_IN_SCREEN;
_ShadowMapMaxCasterAround= NL3D_SCENE_DEFAULT_SHADOW_MAP_MAX_CASTER_AROUND;
_VisualCollisionManagerForShadow= NULL;
_WaterCallback = NULL;
_PolyDrawingCallback = NULL;
_IsRendering = false;
_FirstFlare = NULL;
_RenderedPart = UScene::RenderNothing;
//_WaterEnvMapRdr = NULL;
//_WaterEnvMap = new CTextureCube;
_WaterEnvMap = NULL;
_GlobalSystemTime= 0.0;
_RequestParticlesAnimate = false;
}
// ***************************************************************************
void CScene::release()
{
// reset the _QuadGridClipManager, => unlink models, and delete clusters.
if( _QuadGridClipManager )
_QuadGridClipManager->reset();
// First, delete models.
set<CTransform*>::iterator it;
it= _Models.begin();
while( it!=_Models.end())
{
CTransform *tr= *it;
// Don't delete The Roots, because used, for instance in ~CSkeletonModel()
if(tr!=Root && tr!=RootCluster && tr!=SonsOfAncestorSkeletonModelGroup)
deleteModel(tr);
// temp erase from the list
else
_Models.erase(it);
// NB: important to take begin(), and not it++, cause ~CSkeletonModel() may delete ScriptSpawned models
it= _Models.begin();
}
// Then delete the roots
// reinsert
if(Root) _Models.insert(Root);
if(RootCluster) _Models.insert(RootCluster);
if(SonsOfAncestorSkeletonModelGroup) _Models.insert(SonsOfAncestorSkeletonModelGroup);
// delete in the reverse order of initDefaultRoots()
if(SonsOfAncestorSkeletonModelGroup)
{
deleteModel(SonsOfAncestorSkeletonModelGroup);
SonsOfAncestorSkeletonModelGroup= NULL;
}
if(RootCluster)
{
deleteModel(RootCluster);
RootCluster= NULL;
}
if(Root)
{
deleteModel(Root);
Root= NULL;
}
// No models at all.
_UpdateModelList= NULL;
// reset ptrs
_ShapeBank = NULL;
Root= NULL;
RootCluster= NULL;
SonsOfAncestorSkeletonModelGroup= NULL;
CurrentCamera= NULL;
_QuadGridClipManager= NULL;
ClipTrav.setQuadGridClipManager(NULL);
// DON'T reset the _LodCharacterManager, because it can be shared across scenes
/*
if(_LodCharacterManager)
_LodCharacterManager->reset();
*/
_LodCharacterManager= NULL;
// delete the coarseMeshManager
if(_CoarseMeshManager)
{
delete _CoarseMeshManager;
_CoarseMeshManager= NULL;
}
if(_GlobalInstanceGroup)
{
delete _GlobalInstanceGroup;
_GlobalInstanceGroup = NULL;
}
// delete the play list
_LMAnimsAuto.deleteAll();
}
// ***************************************************************************
CScene::~CScene()
{
release();
}
// ***************************************************************************
void CScene::initDefaultRoots()
{
// Create and set root the default models.
Root= static_cast<CTransform*>(createModel(TransformId));
// The root is always freezed (never move).
Root->freeze();
// Init the instance group that represent the world
_GlobalInstanceGroup = new CInstanceGroup;
RootCluster= (CCluster*)createModel (ClusterId);
// unlink from hrc.
RootCluster->hrcUnlink();
RootCluster->Name = "ClusterRoot";
RootCluster->Group = _GlobalInstanceGroup;
_GlobalInstanceGroup->addCluster (RootCluster);
// init the ClipTrav.RootCluster.
ClipTrav.RootCluster = RootCluster;
// Create a SonsOfAncestorSkeletonModelGroup, for models which have a skeleton ancestor
SonsOfAncestorSkeletonModelGroup= static_cast<CRootModel*>(createModel(RootModelId));
// must unlink it from all traversals, because special, only used in CClipTrav::traverse()
SonsOfAncestorSkeletonModelGroup->hrcUnlink();
Root->clipDelChild(SonsOfAncestorSkeletonModelGroup);
}
// ***************************************************************************
void CScene::initQuadGridClipManager ()
{
// Init clip features.
if( !_QuadGridClipManager )
{
// create the model
_QuadGridClipManager= static_cast<CQuadGridClipManager*>(createModel(QuadGridClipManagerId));
// unlink it from hrc, and link it only to RootCluster.
// NB: hence the quadGridClipManager may be clipped by the cluster system
_QuadGridClipManager->hrcUnlink();
_QuadGridClipManager->clipUnlinkFromAll();
RootCluster->clipAddChild(_QuadGridClipManager);
// init _QuadGridClipManager.
_QuadGridClipManager->init(NL3D_QuadGridClipClusterSize,
NL3D_QuadGridClipNumDist,
NL3D_QuadGridClipMaxDist,
NL3D_QuadGridClipManagerRadiusMax);
}
}
// ***************************************************************************
void CScene::render(bool doHrcPass)
{
beginPartRender();
renderPart(UScene::RenderAll, doHrcPass);
endPartRender();
}
// ***************************************************************************
void CScene::beginPartRender()
{
nlassert(!_IsRendering);
// Do not delete model during the rendering
// Also do not create model with CSkeletonSpawnScript model animation
_IsRendering = true;
_RenderedPart= UScene::RenderNothing;
}
// ***************************************************************************
void CScene::endPartRender(bool keepTrav)
{
nlassert(_IsRendering);
_IsRendering = false;
if (!keepTrav)
{
// Delete model deleted during the rendering
uint i;
for (i=0; i<_ToDelete.size(); i++)
deleteModel (_ToDelete[i]);
_ToDelete.clear ();
// Special for SkeletonSpawnScript animation. create models spawned now
flushSSSModelRequests();
// Particle system handling (remove the resources of those which are too far, as their clusters may not have been parsed).
// Note that only a few of them are tested at each call
_ParticleSystemManager.refreshModels(ClipTrav.WorldFrustumPyramid, ClipTrav.CamPos);
// Waiting Instance handling
double deltaT = _DeltaSystemTimeBetweenRender;
clamp (deltaT, 0.01, 0.1);
updateWaitingInstances(deltaT);
}
// Reset profiling
_NextRenderProfile= false;
IDriver *drv = getDriver();
drv->activeVertexProgram(NULL);
drv->activePixelProgram(NULL);
drv->activeGeometryProgram(NULL);
// Ensure nothing animates on subsequent renders
_EllapsedTime = 0.f;
/*
uint64 total = PSStatsRegisterPSModelObserver +
PSStatsRemovePSModelObserver +
PSStatsUpdateOpacityInfos +
PSStatsUpdateLightingInfos +
PSStatsGetAABBox +
PSStatsReallocRsc +
PSStatsReleasePSPointer +
PSStatsRefreshRscDeletion +
PSStatsReleaseRsc +
PSStatsReleaseRscAndInvalidate +
PSStatsGetNumTriangles +
PSStatsCheckAgainstPyramid +
PSStatsTraverseAnimDetail +
PSStatsDoAnimate +
PSStatsTraverseRender +
PSStatsTraverseClip +
PSStatsCheckDestroyCondition +
PSStatsForceInstanciate +
PSStatsDoAnimatePart1 +
PSStatsDoAnimatePart2 +
PSStatsDoAnimatePart3 +
PSStatsTraverseAnimDetailPart1 +
PSStatsTraverseAnimDetailPart2 +
PSStatsTraverseAnimDetailPart3 +
PSStatsTraverseAnimDetailPart4 +
PSAnim1 +
PSAnim2+
PSAnim3+
PSAnim4+
PSAnim5+
PSAnim6+
PSAnim7+
PSAnim8+
PSAnim9+
PSAnim10+
PSAnim11;
if (((double) total / (double) NLMISC::CSystemInfo::getProcessorFrequency()) > 0.01)
{
nlinfo("***** PS STATS ****");
#define PS_STATS(var) \
nlinfo("time for " #var " = %.2f", (float) (1000 * ((double) var / (double) CSystemInfo::getProcessorFrequency())));
PS_STATS(PSStatsRegisterPSModelObserver)
PS_STATS(PSStatsRemovePSModelObserver)
PS_STATS(PSStatsUpdateOpacityInfos)
PS_STATS(PSStatsUpdateLightingInfos)
PS_STATS(PSStatsGetAABBox)
PS_STATS(PSStatsReallocRsc)
PS_STATS(PSStatsReleasePSPointer)
PS_STATS(PSStatsRefreshRscDeletion)
PS_STATS(PSStatsReleaseRsc)
PS_STATS(PSStatsReleaseRscAndInvalidate)
PS_STATS(PSStatsGetNumTriangles)
PS_STATS(PSStatsCheckAgainstPyramid)
PS_STATS(PSStatsTraverseAnimDetail)
PS_STATS(PSStatsDoAnimate)
PS_STATS(PSStatsTraverseRender)
PS_STATS(PSStatsTraverseClip)
PS_STATS(PSStatsClipSystemInstanciated);
PS_STATS(PSStatsClipSystemNotInstanciated);
PS_STATS(PSStatsClipSystemCheckAgainstPyramid);
PS_STATS(PSStatsInsertInVisibleList);
PS_STATS(PSStatsCheckDestroyCondition)
PS_STATS(PSStatsForceInstanciate)
PS_STATS(PSStatsDoAnimatePart1)
PS_STATS(PSStatsDoAnimatePart2)
PS_STATS(PSStatsDoAnimatePart3)
PS_STATS(PSStatsTraverseAnimDetailPart1)
PS_STATS(PSStatsTraverseAnimDetailPart2)
PS_STATS(PSStatsTraverseAnimDetailPart3)
PS_STATS(PSStatsTraverseAnimDetailPart4)
PS_STATS(PSAnim1)
PS_STATS(PSAnim2)
PS_STATS(PSAnim3)
PS_STATS(PSAnim4)
PS_STATS(PSAnim5)
PS_STATS(PSAnim6)
PS_STATS(PSAnim7)
PS_STATS(PSAnim8)
PS_STATS(PSAnim9)
PS_STATS(PSAnim10)
PS_STATS(PSAnim11)
PS_STATS(PSStatsZonePlane)
PS_STATS(PSStatsZoneSphere)
PS_STATS(PSStatsZoneDisc)
PS_STATS(PSStatsZoneRectangle)
PS_STATS(PSStatsZoneCylinder)
PS_STATS(PSMotion1)
PS_STATS(PSMotion2)
PS_STATS(PSMotion3)
PS_STATS(PSMotion4)
PS_STATS(PSStatCollision)
PS_STATS(PSStatEmit)
PS_STATS(PSStatRender)
nlinfo("num do animate = %d", (int) PSStatsNumDoAnimateCalls);
nlinfo("Max et = %.2f", PSMaxET);
nlinfo("Max ps nb pass = %d", (int) PSMaxNBPass);
PS_STATS(total)
}
PSStatsRegisterPSModelObserver = 0;
PSStatsRemovePSModelObserver = 0;
PSStatsUpdateOpacityInfos = 0;
PSStatsUpdateLightingInfos = 0;
PSStatsGetAABBox = 0;
PSStatsReallocRsc = 0;
PSStatsReleasePSPointer = 0;
PSStatsRefreshRscDeletion = 0;
PSStatsReleaseRsc = 0;
PSStatsReleaseRscAndInvalidate = 0;
PSStatsGetNumTriangles = 0;
PSStatsCheckAgainstPyramid = 0;
PSStatsTraverseAnimDetail = 0;
PSStatsDoAnimate = 0;
PSStatsTraverseRender = 0;
PSStatsTraverseClip = 0;
PSStatsCheckDestroyCondition = 0;
PSStatsForceInstanciate = 0;
PSStatsClipSystemInstanciated = 0;
PSStatsClipSystemNotInstanciated = 0;
PSStatsClipSystemCheckAgainstPyramid = 0;
PSStatsInsertInVisibleList = 0;
PSStatsDoAnimatePart1 = 0;
PSStatsDoAnimatePart2 = 0;
PSStatsDoAnimatePart3 = 0;
PSStatsTraverseAnimDetailPart1 = 0;
PSStatsTraverseAnimDetailPart2 = 0;
PSStatsTraverseAnimDetailPart3 = 0;
PSStatsTraverseAnimDetailPart4 = 0;
PSStatsNumDoAnimateCalls = 0;
PSAnim1 = 0;
PSAnim2 = 0;
PSAnim3 = 0;
PSAnim4 = 0;
PSAnim5 = 0;
PSAnim6 = 0;
PSAnim7 = 0;
PSAnim8 = 0;
PSAnim9 = 0;
PSAnim10 = 0;
PSAnim11 = 0;
PSMaxET = 0.f;
PSMaxNBPass = 0;
PSStatsZonePlane = 0;
PSStatsZoneSphere = 0;
PSStatsZoneDisc = 0;
PSStatsZoneRectangle = 0;
PSStatsZoneCylinder = 0;
PSMotion1 = 0;
PSMotion2 = 0;
PSMotion3 = 0;
PSMotion4 = 0;
PSStatCollision = 0;
PSStatEmit = 0;
PSStatRender = 0;
*/
}
// ***************************************************************************
void CScene::renderPart(UScene::TRenderPart rp, bool doHrcPass, bool doTrav, bool keepTrav)
{
nlassert(_IsRendering);
// if nothing (????), abort
if(rp==UScene::RenderNothing)
return;
// If part asked already rendered, abort
nlassert((rp & _RenderedPart) == 0); // cannot render the same part twice during a render
// if first part to be rendered, do the start stuff
if (_RenderedPart == UScene::RenderNothing)
{
RenderTrav.clearWaterModelList();
if (doTrav)
{
// update water envmap
//updateWaterEnvmap();
_FirstFlare = NULL;
double fNewGlobalSystemTime = NLMISC::CTime::ticksToSecond(NLMISC::CTime::getPerformanceTime());
if(_GlobalSystemTime==0)
_DeltaSystemTimeBetweenRender= 0.020;
else
_DeltaSystemTimeBetweenRender= fNewGlobalSystemTime - _GlobalSystemTime;
_GlobalSystemTime = fNewGlobalSystemTime;
}
//
++ _NumRender;
//
nlassert(CurrentCamera);
// update models.
updateModels();
// Use the camera to setup Clip / Render pass.
float left, right, bottom, top, znear, zfar;
CurrentCamera->getFrustum(left, right, bottom, top, znear, zfar);
// setup basic camera.
ClipTrav.setFrustum(left, right, bottom, top, znear, zfar, CurrentCamera->isPerspective());
RenderTrav.setFrustum (left, right, bottom, top, znear, zfar, CurrentCamera->isPerspective());
RenderTrav.setViewport (_Viewport);
LoadBalancingTrav.setFrustum (left, right, bottom, top, znear, zfar, CurrentCamera->isPerspective());
// Set Infos for cliptrav.
ClipTrav.Camera = CurrentCamera;
ClipTrav.setQuadGridClipManager (_QuadGridClipManager);
// **** For all render traversals, traverse them (except the Hrc one), in ascending order.
if( doHrcPass )
HrcTrav.traverse();
else
HrcTrav._MovingObjects.clear();
// Set Cam World Matrix for all trav that need it
ClipTrav.setCamMatrix(CurrentCamera->getWorldMatrix());
RenderTrav.setCamMatrix (CurrentCamera->getWorldMatrix());
LoadBalancingTrav.setCamMatrix (CurrentCamera->getWorldMatrix());
// clip
ClipTrav.traverse();
if (doTrav)
{
// animDetail
AnimDetailTrav.traverse();
}
// loadBalance
LoadBalancingTrav.traverse();
if (doTrav)
{
//
if (_RequestParticlesAnimate)
{
_ParticleSystemManager.processAnimate(_EllapsedTime); // deals with permanently animated particle systems
_RequestParticlesAnimate = false;
}
}
// Light
LightTrav.traverse();
}
// render
RenderTrav.traverse(rp, (_RenderedPart == UScene::RenderNothing), doTrav);
if (!keepTrav)
{
// Always must clear shadow caster (if render did not work because of IDriver::isLost())
RenderTrav.getShadowMapManager().clearAllShadowCasters();
}
// render flare
if (rp & UScene::RenderFlare)
{
if (doTrav)
{
if (_FirstFlare)
{
IDriver *drv = getDriver();
CFlareModel::updateOcclusionQueryBegin(drv);
CFlareModel *currFlare = _FirstFlare;
do
{
currFlare->updateOcclusionQuery(drv);
currFlare = currFlare->Next;
}
while(currFlare);
CFlareModel::updateOcclusionQueryEnd(drv);
}
}
else
{
_FirstFlare = NULL;
}
}
_RenderedPart = (UScene::TRenderPart) (_RenderedPart | rp);
}
// ***************************************************************************
void CScene::updateWaitingInstances(double systemTimeEllapsed)
{
// First set up max AGP upload
double fMaxBytesToUp = 100 * 256 * 256 * systemTimeEllapsed;
_ShapeBank->setMaxBytesToUpload ((uint32)fMaxBytesToUp);
// Parse all the waiting instance
_ShapeBank->processWaitingShapes (); // Process waiting shapes load shape, texture, and lightmaps
// and upload all maps to VRAM pieces by pieces
TWaitingInstancesMMap::iterator wimmIt = _WaitingInstances.begin();
while( wimmIt != _WaitingInstances.end() )
{
CShapeBank::TShapeState st = _ShapeBank->getPresentState (wimmIt->first);
if (st == CShapeBank::AsyncLoad_Error)
{
// Delete the waiting instance - Nobody can be informed of that...
TWaitingInstancesMMap::iterator itDel= wimmIt;
++wimmIt;
_WaitingInstances.erase(itDel);
}
else if (st == CShapeBank::Present)
{
// Then create a reference to the shape
*(wimmIt->second) = _ShapeBank->addRef(wimmIt->first)->createInstance (*this);
// Delete the waiting instance
TWaitingInstancesMMap::iterator itDel= wimmIt;
++wimmIt;
_WaitingInstances.erase(itDel);
}
else // st == CShapeBank::NotPresent or loading
{
++wimmIt;
}
}
}
// ***************************************************************************
void CScene::setDriver(IDriver *drv)
{
RenderTrav.setDriver(drv);
}
// ***************************************************************************
IDriver *CScene::getDriver() const
{
return (const_cast<CScene*>(this))->RenderTrav.getDriver();
}
// ***************************************************************************
// ***************************************************************************
// Shape mgt.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CScene::setShapeBank(CShapeBank*pShapeBank)
{
_ShapeBank = pShapeBank;
}
// ***************************************************************************
CTransformShape *CScene::createInstance(const string &shapeName)
{
// We must attach a bank to the scene (a ShapeBank handle the shape caches and
// the creation/deletion of the instances)
nlassert( _ShapeBank != NULL );
// If the shape is not present in the bank
if (_ShapeBank->getPresentState( shapeName ) != CShapeBank::Present)
{
// Load it from file
_ShapeBank->load( shapeName );
if (_ShapeBank->getPresentState( shapeName ) != CShapeBank::Present)
{
return NULL;
}
}
// Then create a reference to the shape
CTransformShape *pTShp = _ShapeBank->addRef( shapeName )->createInstance(*this);
if (pTShp) pTShp->setDistMax(pTShp->Shape->getDistMax());
// Look if this instance get lightmap information
#if defined(__GNUC__) && __GNUC__ < 3
CMeshBase *pMB = (CMeshBase*)((IShape*)(pTShp->Shape));
#else // not GNUC
CMeshBase *pMB = dynamic_cast<CMeshBase*>((IShape*)(pTShp->Shape));
#endif // not GNUC
CMeshBaseInstance *pMBI = dynamic_cast<CMeshBaseInstance*>( pTShp );
if( ( pMB != NULL ) && ( pMBI != NULL ) )
{
// Init lightmap information
pMBI->initAnimatedLightIndex (*this);
// Auto animations
//==========================
if (_AutomaticAnimationSet)
{
if (pMB->getAutoAnim())
{
std::string animName = toLower(CFile::getFilenameWithoutExtension(shapeName));
uint animID = _AutomaticAnimationSet->getAnimationIdByName(animName);
if (animID != CAnimationSet::NotFound)
{
CChannelMixer *chanMix = new CChannelMixer;
chanMix->setAnimationSet((CAnimationSet *) _AutomaticAnimationSet);
chanMix->setSlotAnimation(0, animID);
pMBI->registerToChannelMixer(chanMix, "");
// Gives this object ownership of the channel mixer so we don't need to keep track of it
pMBI->setChannelMixerOwnerShip(true);
}
}
}
}
CLandscapeModel *pLM = dynamic_cast<CLandscapeModel*>( pTShp );
if( pLM != NULL )
{
// Init lightmap information
pLM->Landscape.initAnimatedLightIndex (*this);
}
return pTShp;
}
// ***************************************************************************
void CScene::createInstanceAsync(const string &shapeName, CTransformShape **pInstance, const NLMISC::CVector &position, uint selectedTexture)
{
// We must attach a bank to the scene (a ShapeBank handle the shape caches and
// the creation/deletion of the instances)
nlassert( _ShapeBank != NULL );
*pInstance = NULL;
// Add the instance request
_WaitingInstances.insert(TWaitingInstancesMMap::value_type(shapeName,pInstance));
// If the shape is not present in the bank
if (_ShapeBank->getPresentState( shapeName ) != CShapeBank::Present)
{
// Load it from file asynchronously
_ShapeBank->loadAsync( toLower(shapeName), getDriver(), position, NULL, selectedTexture);
}
}
// ***************************************************************************
void CScene::deleteInstance(CTransformShape *pTrfmShp)
{
IShape *pShp = NULL;
if( pTrfmShp == NULL )
return;
pShp = pTrfmShp->Shape;
deleteModel( pTrfmShp );
if (pShp)
{
// Even if model already deleted by smarptr the release function works
_ShapeBank->release( pShp );
}
}
// ***************************************************************************
void CScene::animate( TGlobalAnimationTime atTime )
{
// todo hulud remove
if (_FirstAnimateCall)
{
_InitTime = atTime;
_RealTime = atTime;
// dummy value for first frame
_EllapsedTime = 0.01f ;
_FirstAnimateCall = false ;
}
else
{
_EllapsedTime = (float) (atTime - _RealTime);
//nlassert(_EllapsedTime >= 0);
if (_EllapsedTime < 0.0f) // NT WorkStation PATCH (Yes you are not dreaming
_EllapsedTime = 0.01f; // deltaTime can be less than zero!!)
_EllapsedTime = fabsf(_EllapsedTime);
_RealTime = atTime ;
_CurrentTime += _EllapsedTime;
}
_LMAnimsAuto.animate( atTime );
// Change PointLightFactors of all pointLights in registered Igs.
//----------------
// First list all current AnimatedLightmaps (for faster vector iteration per ig)
const uint count = (uint)_AnimatedLightPtr.size ();
uint i;
for (i=0; i<count; i++)
{
// Blend final colors
_AnimatedLightPtr[i]->updateGroupColors (*this);
}
// For all registered igs.
ItAnimatedIgSet itAnIgSet;
for(itAnIgSet= _AnimatedIgSet.begin(); itAnIgSet!=_AnimatedIgSet.end(); itAnIgSet++)
{
CInstanceGroup *ig= *itAnIgSet;
// Set the light factor
ig->setPointLightFactor(*this);
}
// Rendered part are invalidate
_RenderedPart = UScene::RenderNothing;
// Particles are animated later due to dependencies
_RequestParticlesAnimate = true;
}
// ***************************************************************************
float CScene::getNbFaceAsked () const
{
return LoadBalancingTrav.getNbFaceAsked ();
}
// ***************************************************************************
void CScene::setGroupLoadMaxPolygon(const std::string &group, uint nFaces)
{
nFaces= max(nFaces, (uint)1);
LoadBalancingTrav.setGroupNbFaceWanted(group, nFaces);
}
// ***************************************************************************
uint CScene::getGroupLoadMaxPolygon(const std::string &group)
{
return LoadBalancingTrav.getGroupNbFaceWanted(group);
}
// ***************************************************************************
float CScene::getGroupNbFaceAsked (const std::string &group) const
{
return LoadBalancingTrav.getGroupNbFaceAsked(group);
}
// ***************************************************************************
void CScene::setPolygonBalancingMode(TPolygonBalancingMode polBalMode)
{
LoadBalancingTrav.PolygonBalancingMode= (CLoadBalancingGroup::TPolygonBalancingMode)(uint)polBalMode;
}
// ***************************************************************************
CScene::TPolygonBalancingMode CScene::getPolygonBalancingMode() const
{
return (CScene::TPolygonBalancingMode)(uint)LoadBalancingTrav.PolygonBalancingMode;
}
// ***************************************************************************
void CScene::setLayersRenderingOrder(bool directOrder /*= true*/)
{
RenderTrav.setLayersRenderingOrder(directOrder);
}
// ***************************************************************************
bool CScene::getLayersRenderingOrder() const
{
return RenderTrav.getLayersRenderingOrder();
}
// ***************************************************************************
CParticleSystemManager &CScene::getParticleSystemManager()
{
return _ParticleSystemManager;
}
// ***************************************************************************
void CScene::enableElementRender(UScene::TRenderFilter elt, bool state)
{
if(state)
_FilterRenderFlags|= (uint32)elt;
else
_FilterRenderFlags&= ~(uint32)elt;
}
// ***************************************************************************
// ***************************************************************************
// Lighting Mgt.
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CScene::enableLightingSystem(bool enable)
{
_LightingSystemEnabled= enable;
// Set to RenderTrav and LightTrav
RenderTrav.LightingSystemEnabled= _LightingSystemEnabled;
LightTrav.LightingSystemEnabled= _LightingSystemEnabled;
}
// ***************************************************************************
void CScene::setAmbientGlobal(NLMISC::CRGBA ambient)
{
RenderTrav.AmbientGlobal= ambient;
}
void CScene::setSunAmbient(NLMISC::CRGBA ambient)
{
RenderTrav.SunAmbient= ambient;
}
void CScene::setSunDiffuse(NLMISC::CRGBA diffuse)
{
RenderTrav.SunDiffuse= diffuse;
}
void CScene::setSunSpecular(NLMISC::CRGBA specular)
{
RenderTrav.SunSpecular= specular;
}
void CScene::setSunDirection(const NLMISC::CVector &direction)
{
RenderTrav.setSunDirection(direction);
}
// ***************************************************************************
NLMISC::CRGBA CScene::getAmbientGlobal() const
{
return RenderTrav.AmbientGlobal;
}
NLMISC::CRGBA CScene::getSunAmbient() const
{
return RenderTrav.SunAmbient;
}
NLMISC::CRGBA CScene::getSunDiffuse() const
{
return RenderTrav.SunDiffuse;
}
NLMISC::CRGBA CScene::getSunSpecular() const
{
return RenderTrav.SunSpecular;
}
NLMISC::CVector CScene::getSunDirection() const
{
return RenderTrav.getSunDirection();
}
// ***************************************************************************
void CScene::setMaxLightContribution(uint nlights)
{
LightTrav.LightingManager.setMaxLightContribution(nlights);
}
uint CScene::getMaxLightContribution() const
{
return LightTrav.LightingManager.getMaxLightContribution();
}
void CScene::setLightTransitionThreshold(float lightTransitionThreshold)
{
LightTrav.LightingManager.setLightTransitionThreshold(lightTransitionThreshold);
}
float CScene::getLightTransitionThreshold() const
{
return LightTrav.LightingManager.getLightTransitionThreshold();
}
// ***************************************************************************
void CScene::addInstanceGroupForLightAnimation(CInstanceGroup *ig)
{
nlassert( ig );
nlassert( _AnimatedIgSet.find(ig) == _AnimatedIgSet.end() );
_AnimatedIgSet.insert(ig);
}
// ***************************************************************************
void CScene::removeInstanceGroupForLightAnimation(CInstanceGroup *ig)
{
nlassert( ig );
ItAnimatedIgSet itIg= _AnimatedIgSet.find(ig);
if ( itIg != _AnimatedIgSet.end() )
_AnimatedIgSet.erase(itIg);
}
// ***************************************************************************
void CScene::setCoarseMeshLightingUpdate(uint8 period)
{
_CoarseMeshLightingUpdate= max((uint8)1, period);
}
// ***************************************************************************
// ***************************************************************************
/// Weather mgt
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CScene::setGlobalWindPower(float gwp)
{
_GlobalWindPower= gwp;
}
// ***************************************************************************
void CScene::setGlobalWindDirection(const CVector &gwd)
{
_GlobalWindDirection= gwd;
_GlobalWindDirection.z= 0;
_GlobalWindDirection.normalize();
}
// ***************************************************************************
// ***************************************************************************
/// Private
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
CScene::ItSkeletonModelList CScene::appendSkeletonModelToList(CSkeletonModel *skel)
{
_SkeletonModelList.push_front(skel);
return _SkeletonModelList.begin();
}
// ***************************************************************************
void CScene::eraseSkeletonModelToList(CScene::ItSkeletonModelList it)
{
_SkeletonModelList.erase(it);
}
// ***************************************************************************
void CScene::registerShadowCasterToList(CTransform *sc)
{
nlassert(sc);
_ShadowCasterList.push_front(sc);
sc->_ItShadowCasterInScene= _ShadowCasterList.begin();
}
// ***************************************************************************
void CScene::unregisterShadowCasterToList(CTransform *sc)
{
nlassert(sc);
_ShadowCasterList.erase(sc->_ItShadowCasterInScene);
}
// ***************************************************************************
// ***************************************************************************
// Old CMOT integrated methods
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
set<CScene::CModelEntry> CScene::_RegModels;
// ***************************************************************************
void CScene::registerModel(const CClassId &idModel, const CClassId &idModelBase, CTransform* (*creator)())
{
nlassert(idModel!=CClassId::Null);
nlassert(creator);
// idModelBase may be Null...
CModelEntry e;
e.BaseModelId= idModelBase;
e.ModelId= idModel;
e.Creator= creator;
// Insert/replace e.
_RegModels.erase(e);
_RegModels.insert(e);
}
// ***************************************************************************
CTransform *CScene::createModel(const CClassId &idModel)
{
nlassert(idModel!=CClassId::Null);
CModelEntry e;
e.ModelId= idModel;
set<CModelEntry>::iterator itModel;
itModel= _RegModels.find(e);
if(itModel==_RegModels.end())
{
nlstop; // Warning, CScene::registerBasics () has not been called !
return NULL;
}
else
{
CTransform *m= (*itModel).Creator();
if(!m) return NULL;
// Set the owner for the model.
m->_OwnerScene= this;
// link model to Root in HRC and in clip. NB: if exist!! (case for the Root and RootCluster :) )
if(Root)
{
Root->hrcLinkSon(m);
Root->clipAddChild(m);
}
// Insert the model into the set.
_Models.insert(m);
// By default the model is update() in CScene::updateModels().
m->linkToUpdateList();
// Once the model is correclty created, finish init him.
m->initModel();
// Ensure all the Traversals has enough space for visible list.
ClipTrav.reserveVisibleList((uint)_Models.size());
AnimDetailTrav.reserveVisibleList((uint)_Models.size());
LoadBalancingTrav.reserveVisibleList((uint)_Models.size());
LightTrav.reserveLightedList((uint)_Models.size());
RenderTrav.reserveRenderList((uint)_Models.size());
return m;
}
}
// ***************************************************************************
void CScene::deleteModel(CTransform *model)
{
if(model==NULL)
return;
// No model delete during the render
if (_IsRendering)
{
// add ot list of object to delete
_ToDelete.push_back (model);
// remove this object from the RenderTrav, hence it won't be displayed
// still animDetail/Light/LoadBalance it. This is useless, but very rare
// and I prefer doing like this than to add a NULL ptr Test in each Traversal (which I then must do in CRenderTrav)
RenderTrav.removeRenderModel(model);
}
// standard delete
else
{
set<CTransform*>::iterator it= _Models.find(model);
if(it!=_Models.end())
{
delete *it;
_Models.erase(it);
}
}
}
// ***************************************************************************
void CScene::updateModels()
{
// check all the models which must be checked.
CTransform *model= _UpdateModelList;
CTransform *next;
while( model )
{
// next to update. get next now, because model->update() may remove model from the list.
next= model->_NextModelToUpdate;
// update the model.
model->update();
// next.
model= next;
}
}
// ***************************************************************************
void CScene::setLightGroupColor(uint lightmapGroup, NLMISC::CRGBA color)
{
// If too small, resize with white
if (lightmapGroup >= _LightGroupColor.size ())
{
_LightGroupColor.resize (lightmapGroup+1, CRGBA::White);
}
// Set the color
_LightGroupColor[lightmapGroup] = color;
}
// ***************************************************************************
sint CScene::getAnimatedLightNameToIndex (const std::string &name) const
{
std::map<std::string, uint>::const_iterator ite = _AnimatedLightNameToIndex.find (name);
if (ite != _AnimatedLightNameToIndex.end ())
return (sint)ite->second;
else
return -1;
}
// ***************************************************************************
void CScene::setAutomaticAnimationSet(CAnimationSet *as)
{
// Backup the animation set
_AutomaticAnimationSet = as;
// Delete all auto lightmap animations
_LMAnimsAuto.deleteAll();
_AnimatedLightNameToIndex.clear();
_AnimatedLight.clear();
_AnimatedLightPtr.clear();
_LightGroupColor.clear();
// Register each animation as lightmap
const uint count = _AutomaticAnimationSet->getNumAnimation();
uint i;
for (i=0; i<count; i++)
{
// Pointer on the animation
CAnimation *pAnim = _AutomaticAnimationSet->getAnimation(i);
/* uint nAnimNb;
// Reset the automatic animation if no animation wanted
if( pAnim == NULL )
{
_AnimatedLight.clear();
_AnimatedLightPtr.clear();
_AnimatedLightNameToIndex.clear();
nAnimNb = _LightmapAnimations.getAnimationIdByName("Automatic");
if( nAnimNb != CAnimationSet::NotFound )
{
CAnimation *anim = _LightmapAnimations.getAnimation( nAnimNb );
delete anim;
}
_LightmapAnimations.reset();
_LMAnimsAuto.deleteAll();
return;
}
*/
set<string> setTrackNames;
pAnim->getTrackNames( setTrackNames );
// nAnimNb = _LightmapAnimations.addAnimation( "Automatic", pAnim );
// _LightmapAnimations.build();
set<string>::iterator itSel = setTrackNames.begin();
while ( itSel != setTrackNames.end() )
{
string ate = *itSel;
if( strncmp( itSel->c_str(), "LightmapController.", 19 ) == 0 )
{
// The light name
const char *lightName = strrchr ((*itSel).c_str (), '.')+1;
// Light animation doesn't exist ?
if (_AnimatedLightNameToIndex.find (lightName) == _AnimatedLightNameToIndex.end())
{
// Channel mixer for light anim
CChannelMixer *cm = new CChannelMixer();
cm->setAnimationSet( _AutomaticAnimationSet );
// Add an automatic animation
_AnimatedLight.push_back ( CAnimatedLightmap ((uint)_LightGroupColor.size ()) );
_AnimatedLightPtr.push_back ( &_AnimatedLight.back () );
_AnimatedLightNameToIndex.insert ( std::map<std::string, uint>::value_type (lightName, (uint32)_AnimatedLightPtr.size ()-1 ) );
CAnimatedLightmap &animLM = _AnimatedLight.back ();
animLM.setName( *itSel );
cm->addChannel( animLM.getName(), &animLM, animLM.getValue(CAnimatedLightmap::FactorValue),
animLM.getDefaultTrack(CAnimatedLightmap::FactorValue), CAnimatedLightmap::FactorValue,
CAnimatedLightmap::OwnerBit, false);
// Animated lightmap playlist
CAnimationPlaylist *pl = new CAnimationPlaylist();
pl->setAnimation( 0, i );
pl->setWrapMode( 0, CAnimationPlaylist::Repeat );
_LMAnimsAuto.addPlaylist(pl,cm);
}
}
++itSel;
}
}
}
// ***************************************************************************
// ***************************************************************************
/// Misc
// ***************************************************************************
// ***************************************************************************
// ***************************************************************************
void CScene::profileNextRender()
{
_NextRenderProfile= true;
// Reset All Stats.
BenchRes.reset();
}
// ***************************************************************************
void CScene::setShadowMapTextureSize(uint size)
{
size= max(size, 2U);
size= raiseToNextPowerOf2(size);
_ShadowMapTextureSize= size;
}
// ***************************************************************************
void CScene::setShadowMapBlurSize(uint bs)
{
_ShadowMapBlurSize= bs;
}
// ***************************************************************************
void CScene::enableShadowPolySmooth(bool enable)
{
RenderTrav.getShadowMapManager().enableShadowPolySmooth(enable);
}
// ***************************************************************************
bool CScene::getEnableShadowPolySmooth() const
{
return RenderTrav.getShadowMapManager().getEnableShadowPolySmooth();
}
// ***************************************************************************
void CScene::setShadowMapDistFadeStart(float dist)
{
_ShadowMapDistFadeStart= max(0.f, dist);
}
// ***************************************************************************
void CScene::setShadowMapDistFadeEnd(float dist)
{
_ShadowMapDistFadeEnd= max(0.f, dist);
}
// ***************************************************************************
void CScene::setShadowMapMaxCasterInScreen(uint num)
{
_ShadowMapMaxCasterInScreen= num;
}
// ***************************************************************************
void CScene::setShadowMapMaxCasterAround(uint num)
{
_ShadowMapMaxCasterAround= num;
}
// ***************************************************************************
CInstanceGroup *CScene::findCameraClusterSystemFromRay(CInstanceGroup *startClusterSystem,
const NLMISC::CVector &startPos, NLMISC::CVector &endPos)
{
CInstanceGroup *resultCS= NULL;
CClipTrav &clipTrav= getClipTrav();
// **** Search all cluster where the startPos is in
static vector<CCluster*> vCluster;
vCluster.clear();
bool bInWorld = true;
clipTrav.Accel.select (startPos, startPos);
CQuadGrid<CCluster*>::CIterator itAcc = clipTrav.Accel.begin();
while (itAcc != clipTrav.Accel.end())
{
CCluster *pCluster = *itAcc;
if( pCluster->Group == startClusterSystem &&
pCluster->isIn (startPos) )
{
vCluster.push_back (pCluster);
bInWorld = false;
}
++itAcc;
}
if (bInWorld)
{
vCluster.push_back (RootCluster);
}
// **** Do a traverse starting from each start cluser, clipping the ray instead of the camera pyramid
uint i;
static vector<CCluster*> vClusterVisited;
vClusterVisited.clear();
for(i=0;i<vCluster.size();i++)
{
vCluster[i]->cameraRayClip(startPos, endPos, vClusterVisited);
}
// **** From each cluster, select possible clusterSystem
static vector<CInstanceGroup*> possibleClusterSystem;
possibleClusterSystem.clear();
for(i=0;i<vClusterVisited.size();i++)
{
// select only cluster where the EndPos lies in. Important else in landscape, we'll always say
// that we are in a Son Cluster.
if(vClusterVisited[i]->isIn(endPos))
{
CInstanceGroup *cs= vClusterVisited[i]->Group;
// insert if not exist (NB: 1,2 possible clusterSystem so O(N2) is OK)
uint j;
for(j=0;j<possibleClusterSystem.size();j++)
{
if(possibleClusterSystem[j]==cs)
break;
}
if(j==possibleClusterSystem.size())
possibleClusterSystem.push_back(cs);
}
}
// If no cluster found, then we may be in a "Data Error case".
// In this case, ensure the Camera position in a cluster
if(possibleClusterSystem.empty())
{
CCluster *bestCluster= NULL;
float shortDist= FLT_MAX;
for(i=0;i<vClusterVisited.size();i++)
{
// if the ray is at least partially in this cluster
CVector a= startPos;
CVector b= endPos;
if(vClusterVisited[i]->clipSegment(a, b))
{
float dist= (endPos - b).norm();
if(dist<shortDist)
{
bestCluster= vClusterVisited[i];
shortDist= dist;
}
}
}
// if found
if(bestCluster)
{
// append the best one to the possible Cluster System
possibleClusterSystem.push_back(bestCluster->Group);
// and modify endPos, so the camera will really lies into this cluster
const float threshold= 0.05f;
shortDist+= threshold;
// must not goes more than startPos!
float rayDist= (startPos - endPos).norm();
shortDist= min(shortDist, rayDist);
endPos+= (startPos - endPos).normed() * shortDist;
}
}
// NB: still possible that the possibleClusterSystem is empty, if not in any cluster for instance :)
// **** From each possible clusterSystem, select the one that is the lower in hierarchy
// common case
if(possibleClusterSystem.empty())
resultCS= NULL;
else if(possibleClusterSystem.size()==1)
{
// if it is the rootCluster set NULL (should have the same behavior but do like standard case)
if(possibleClusterSystem[0]==RootCluster->getClusterSystem())
resultCS= NULL;
// set this cluster system
else
resultCS= possibleClusterSystem[0];
}
// conflict case
else
{
// compute the hierarchy level of each cluster system, take the highest
CInstanceGroup *highest= NULL;
uint highestLevel= 0;
for(i=0;i<possibleClusterSystem.size();i++)
{
uint level= 0;
CInstanceGroup *ig= possibleClusterSystem[i];
while(ig)
{
ig= ig->getParentClusterSystem();
level++;
}
if(level>=highestLevel)
{
highestLevel= level;
highest= possibleClusterSystem[i];
}
}
// set the highest cluster system
resultCS= highest;
}
return resultCS;
}
// ***************************************************************************
void CScene::renderOcclusionTestMeshsWithCurrMaterial()
{
for(std::set<CTransform*>::iterator it = _Models.begin(); it != _Models.end(); ++it)
{
if ((*it)->isFlare())
{
CFlareModel *flare = NLMISC::safe_cast<CFlareModel *>(*it);
flare->renderOcclusionTestMesh(*RenderTrav.getDriver());
}
}
}
// ***************************************************************************
void CScene::renderOcclusionTestMeshs()
{
nlassert(RenderTrav.getDriver());
RenderTrav.getDriver()->setupViewport(RenderTrav.getViewport());
RenderTrav.getDriver()->activeVertexProgram(NULL);
RenderTrav.getDriver()->activePixelProgram(NULL);
RenderTrav.getDriver()->activeGeometryProgram(NULL);
IDriver::TPolygonMode oldPolygonMode = RenderTrav.getDriver()->getPolygonMode();
CMaterial m;
m.initUnlit();
m.setColor(CRGBA(255, 255, 255, 127));
m.setBlend(true);
m.setDstBlend(CMaterial::invsrcalpha);
m.setSrcBlend(CMaterial::srcalpha);
m.setZWrite(false);
RenderTrav.getDriver()->setupMaterial(m);
getDriver()->setPolygonMode(IDriver::Filled);
renderOcclusionTestMeshsWithCurrMaterial();
m.setColor(CRGBA::Black);
RenderTrav.getDriver()->setupMaterial(m);
getDriver()->setPolygonMode(IDriver::Line);
renderOcclusionTestMeshsWithCurrMaterial();
getDriver()->setPolygonMode(oldPolygonMode);
}
// ***************************************************************************
void CScene::updateWaterEnvMaps(TGlobalAnimationTime time)
{
IDriver *drv = getDriver();
nlassert(drv);
if (_WaterEnvMap)
{
_WaterEnvMap->update(time, *drv);
}
}
// ***************************************************************************
void CScene::addSSSModelRequest(const class CSSSModelRequest &req)
{
_SSSModelRequests.push_back(req);
}
// ***************************************************************************
void CScene::flushSSSModelRequests()
{
for(uint i=0;i<_SSSModelRequests.size();i++)
{
_SSSModelRequests[i].execute();
}
_SSSModelRequests.clear();
}
} // NL3D
Reference in a new issue View git blame Copy permalink