khanat-opennel-code/code/nel/src/3d/scene_user.cpp

// 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/u_point_light.h"
#include "nel/3d/u_instance.h"
#include "nel/3d/u_camera.h"
#include "nel/3d/u_skeleton.h"
#include "nel/3d/scene_user.h"
#include "nel/3d/skeleton_model.h"
#include "nel/3d/coarse_mesh_manager.h"
#include "nel/3d/point_light_model.h"
#include "nel/3d/lod_character_manager.h"
#include "nel/3d/lod_character_shape.h"
#include "nel/3d/lod_character_shape_bank.h"
#include "nel/misc/hierarchical_timer.h"
#include "nel/3d/async_texture_manager.h"
#include "nel/3d/water_env_map_user.h"


using namespace NLMISC;

namespace NL3D
{

H_AUTO_DECL( NL3D_UI_Scene )
H_AUTO_DECL( NL3D_Misc_Scene_CreateDel_Element )
H_AUTO_DECL( NL3D_CreateOrLoad_Instance )
H_AUTO_DECL( NL3D_CreateOrLoad_Skeleton )
H_AUTO_DECL( NL3D_Load_CLodOrCoarseMesh )
H_AUTO_DECL( NL3D_Load_AsyncIG )

#define	NL3D_HAUTO_UI_SCENE						H_AUTO_USE( NL3D_UI_Scene )
#define	NL3D_HAUTO_ELT_SCENE					H_AUTO_USE( NL3D_Misc_Scene_CreateDel_Element )
#define	NL3D_HAUTO_CREATE_INSTANCE				H_AUTO_USE( NL3D_CreateOrLoad_Instance )
#define	NL3D_HAUTO_CREATE_SKELETON				H_AUTO_USE( NL3D_CreateOrLoad_Skeleton )
#define	NL3D_HAUTO_LOAD_LOD						H_AUTO_USE( NL3D_Load_CLodOrCoarseMesh )
#define	NL3D_HAUTO_ASYNC_IG						H_AUTO_USE( NL3D_Load_AsyncIG )

// Render/Animate.
H_AUTO_DECL( NL3D_Render_Scene )
H_AUTO_DECL( NL3D_Render_Animate_Scene )
H_AUTO_DECL( NL3D_Render_Scene_Begin )
H_AUTO_DECL( NL3D_Render_Scene_Part )
H_AUTO_DECL( NL3D_Render_Scene_End )

#define	NL3D_HAUTO_RENDER_SCENE					H_AUTO_USE( NL3D_Render_Scene )
#define	NL3D_HAUTO_RENDER_SCENE_ANIMATE			H_AUTO_USE( NL3D_Render_Animate_Scene )
#define	NL3D_HAUTO_RENDER_SCENE_BEGIN			H_AUTO_USE( NL3D_Render_Scene_Begin )
#define	NL3D_HAUTO_RENDER_SCENE_PART			H_AUTO_USE( NL3D_Render_Scene_Part )
#define	NL3D_HAUTO_RENDER_SCENE_END				H_AUTO_USE( NL3D_Render_Scene_End )




// ***************************************************************************
void			CSceneUser::setAutomaticAnimationSet(UAnimationSet *as)
{
	NL3D_HAUTO_UI_SCENE;

	nlassert(as);
	as->build();
	CAnimationSetUser *asu = NLMISC::safe_cast<CAnimationSetUser *>(as);
	_Scene.setAutomaticAnimationSet(asu->_AnimationSet);
}

// ***************************************************************************
UPlayListManager			*CSceneUser::createPlayListManager()
{
	NL3D_HAUTO_ELT_SCENE;

	return _PlayListManagers.insert(new CPlayListManagerUser());
}
// ***************************************************************************
void			CSceneUser::deletePlayListManager(UPlayListManager	*playListManager)
{
	NL3D_HAUTO_ELT_SCENE;

	_PlayListManagers.erase((CPlayListManagerUser*)playListManager, "deletePlayListManager(): Bad PlayListManager ptr");
}

// ***************************************************************************

void			CSceneUser::setPolygonBalancingMode(CSceneUser::TPolygonBalancingMode polBalMode)
{
	NL3D_HAUTO_UI_SCENE;

	nlassert( (uint)CScene::CountPolygonBalancing == (uint)CSceneUser::CountPolygonBalancing );
	_Scene.setPolygonBalancingMode((CScene::TPolygonBalancingMode)(uint)(polBalMode));
}

// ***************************************************************************

CSceneUser::TPolygonBalancingMode	CSceneUser::getPolygonBalancingMode() const
{
	NL3D_HAUTO_UI_SCENE;

	nlassert( (uint)CScene::CountPolygonBalancing == (uint)CSceneUser::CountPolygonBalancing );
	return (CSceneUser::TPolygonBalancingMode)(uint)_Scene.getPolygonBalancingMode();
}


// ***************************************************************************
float			CSceneUser::getNbFaceAsked () const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getNbFaceAsked ();
}

// ***************************************************************************
void			CSceneUser::setGroupLoadMaxPolygon(const std::string &group, uint nFaces)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setGroupLoadMaxPolygon(group, nFaces);
}
// ***************************************************************************
uint			CSceneUser::getGroupLoadMaxPolygon(const std::string &group)
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getGroupLoadMaxPolygon(group);
}
// ***************************************************************************
float			CSceneUser::getGroupNbFaceAsked (const std::string &group) const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getGroupNbFaceAsked (group);
}


// ***************************************************************************

void CSceneUser::setCoarseMeshManagerTexture (const char *sPath)
{
	NL3D_HAUTO_LOAD_LOD;

	// Get the manager
	CCoarseMeshManager *manager=_Scene.getCoarseMeshManager ();

	// Does it exist ?
	if (manager)
	{
		// Set the texture
		manager->setTextureFile (sPath);
	}
}

// ***************************************************************************
void				CSceneUser::setCoarseMeshLightingUpdate(uint8 period)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setCoarseMeshLightingUpdate(period);
}

// ***************************************************************************
uint8				CSceneUser::getCoarseMeshLightingUpdate() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getCoarseMeshLightingUpdate();
}

// ***************************************************************************
void				CSceneUser::enableLightingSystem(bool enable)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.enableLightingSystem(enable);
}

// ***************************************************************************
void				CSceneUser::setAmbientGlobal(NLMISC::CRGBA ambient)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setAmbientGlobal(ambient);
}
void				CSceneUser::setSunAmbient(NLMISC::CRGBA ambient)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setSunAmbient(ambient);
}
void				CSceneUser::setSunDiffuse(NLMISC::CRGBA diffuse)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setSunDiffuse(diffuse);
}
void				CSceneUser::setSunSpecular(NLMISC::CRGBA specular)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setSunSpecular(specular);
}
void				CSceneUser::setSunDirection(const NLMISC::CVector &direction)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setSunDirection(direction);
}
void				CSceneUser::setLightGroupColor(uint lightmapGroup, NLMISC::CRGBA color)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setLightGroupColor(lightmapGroup, color);
}


// ***************************************************************************
NLMISC::CRGBA		CSceneUser::getAmbientGlobal() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getAmbientGlobal();
}
NLMISC::CRGBA		CSceneUser::getSunAmbient() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getSunAmbient();
}
NLMISC::CRGBA		CSceneUser::getSunDiffuse() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getSunDiffuse();
}
NLMISC::CRGBA		CSceneUser::getSunSpecular() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getSunSpecular();
}
NLMISC::CVector		CSceneUser::getSunDirection() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getSunDirection();
}

// ***************************************************************************

void				CSceneUser::setMaxLightContribution(uint nlights)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setMaxLightContribution(nlights);
}

// ***************************************************************************

uint				CSceneUser::getMaxLightContribution() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getMaxLightContribution();
}

// ***************************************************************************

void				CSceneUser::setLightTransitionThreshold(float lightTransitionThreshold)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setLightTransitionThreshold(lightTransitionThreshold);
}

// ***************************************************************************

float				CSceneUser::getLightTransitionThreshold() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getLightTransitionThreshold();
}

// ***************************************************************************

UPointLight			CSceneUser::createPointLight()
{
	NL3D_HAUTO_ELT_SCENE;

	CTransform	*model= _Scene.createModel(PointLightModelId);
	if (model)
	{
		CPointLightModel *pointLightModel= safe_cast<CPointLightModel*> (model);
		// If not found, return NULL.
		if(pointLightModel==NULL)
			return NULL;

		// The component is auto added/deleted to _Scene in ctor/dtor.
		return UPointLight (pointLightModel);
	}
	else
		return UPointLight ();
}

// ***************************************************************************
void			CSceneUser::deletePointLight(UPointLight &light)
{
	NL3D_HAUTO_ELT_SCENE;

	// The component is auto added/deleted to _Scene in ctor/dtor.
	_Scene.deleteModel (light.getObjectPtr());
	light.detach ();
}


// ***************************************************************************
void			CSceneUser::setGlobalWindPower(float gwp)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setGlobalWindPower(gwp);
}
// ***************************************************************************
float			CSceneUser::getGlobalWindPower() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getGlobalWindPower();
}
// ***************************************************************************
void			CSceneUser::setGlobalWindDirection(const CVector &gwd)
{
	_Scene.setGlobalWindDirection(gwd);
}
// ***************************************************************************
const CVector	&CSceneUser::getGlobalWindDirection() const
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getGlobalWindDirection();
}

// ***************************************************************************
void CSceneUser::updateWaitingIG()
{
	for(TWaitingIGList::iterator it = _WaitingIGs.begin(); it != _WaitingIGs.end();)
	{
		bool	erased= false;
		if (it->IGToLoad != NULL) // ig loaded ?
		{
			if (it->IGToLoad != (UInstanceGroup *) -1)
			{
				switch (it->IGToLoad->getAddToSceneState())
				{
					case UInstanceGroup::StateNotAdded:
						// start loading
						if (it->Callback != NULL)
							it->Callback->InstanceGroupCreated(it->IGToLoad);
						it->IGToLoad->addToSceneAsync(*this, _DriverUser, it->SelectedTexture);
					break;
					case UInstanceGroup::StateAdded:
						it->IGToLoad->setPos(it->Pos);
						it->IGToLoad->setRotQuat(it->Rot);
						this->setToGlobalInstanceGroup(it->IGToLoad);
						*it->CallerPtr = it->IGToLoad;
						// remove from list
						it = _WaitingIGs.erase(it);
						erased= true;
					break;
					case UInstanceGroup::StateError:
						delete it->IGToLoad;
						it->IGToLoad = (UInstanceGroup *) -1;
						*it->CallerPtr = it->IGToLoad;
						// remove from list
						it = _WaitingIGs.erase(it);
						erased= true;
					break;
					default:
					break;
				}
			}
			else
			{
				// loading failed
				*it->CallerPtr = it->IGToLoad;
				it = _WaitingIGs.erase(it);
				erased= true;
			}
		}
		// next IG.
		if(!erased)
			it++;
	}
}


// ***************************************************************************
void				CSceneUser::resetCLodManager()
{
	NL3D_HAUTO_UI_SCENE;

	// DriverUser always setup the lod manager
	nlassert(_Scene.getLodCharacterManager());

	_Scene.getLodCharacterManager()->reset();
}

// ***************************************************************************
uint32				CSceneUser::loadCLodShapeBank(const std::string &fileName)
{
	NL3D_HAUTO_LOAD_LOD;

	// DriverUser always setup the lod manager
	nlassert(_Scene.getLodCharacterManager());

	// Open the file
	CIFile	file(CPath::lookup(fileName));

	// create the shape bank
	uint32	bankId= _Scene.getLodCharacterManager()->createShapeBank();

	// get the bank
	CLodCharacterShapeBank	*bank= _Scene.getLodCharacterManager()->getShapeBank(bankId);
	nlassert(bank);

	// read the bank.
	file.serial(*bank);

	// recompile the shape Map.
	_Scene.getLodCharacterManager()->compile();

	return bankId;
}

// ***************************************************************************
void				CSceneUser::deleteCLodShapeBank(uint32 bankId)
{
	NL3D_HAUTO_LOAD_LOD;

	// DriverUser always setup the lod manager
	nlassert(_Scene.getLodCharacterManager());

	// delete the bank
	_Scene.getLodCharacterManager()->deleteShapeBank(bankId);

	// recompile the shape Map.
	_Scene.getLodCharacterManager()->compile();
}

// ***************************************************************************
sint32				CSceneUser::getCLodShapeIdByName(const std::string &name) const
{
	NL3D_HAUTO_UI_SCENE;

	// DriverUser always setup the lod manager
	nlassert(_Scene.getLodCharacterManager());

	return _Scene.getLodCharacterManager()->getShapeIdByName(name);
}

// ***************************************************************************
sint32				CSceneUser::getCLodAnimIdByName(uint32 shapeId, const std::string &name) const
{
	NL3D_HAUTO_UI_SCENE;

	// DriverUser always setup the lod manager
	nlassert(_Scene.getLodCharacterManager());

	const CLodCharacterShape	*shape= _Scene.getLodCharacterManager()->getShape(shapeId);
	if(shape)
		return shape->getAnimIdByName(name);
	else
		return -1;
}


// ***************************************************************************
void			CSceneUser::render(bool updateWaitingInstancesFlag /*= true*/, bool restoreMatrixContextAfterRender /*= true*/)
{

	// render the scene.
	{
		NL3D_HAUTO_RENDER_SCENE

		if(_Scene.getCam() == NULL)
			nlerror("render(): try to render with no camera linked (may have been deleted)");
		_Scene.render(true);
	}

	if (updateWaitingInstancesFlag) updateWaitingInstances();

	// Must restore the matrix context, so 2D/3D interface not disturbed.
	if (restoreMatrixContextAfterRender) _DriverUser->restoreMatrixContext();
}

// ***************************************************************************
void			CSceneUser::beginPartRender()
{

	// render the scene.
	{
		NL3D_HAUTO_RENDER_SCENE_BEGIN
		_Scene.beginPartRender();
	}
}

// ***************************************************************************
void			CSceneUser::renderPart(TRenderPart rp, bool doHrcPass, bool doTrav, bool keepTrav)
{

	// render the scene.
	{
		NL3D_HAUTO_RENDER_SCENE_PART

		if(_Scene.getCam() == NULL)
			nlerror("render(): try to render with no camera linked (may have been deleted)");
		_Scene.renderPart(rp, doHrcPass, doTrav, keepTrav);
	}
}

// ***************************************************************************
void			CSceneUser::endPartRender(bool updateWaitingInstancesFlag, bool restoreMatrixContextAfterRender, bool keepTrav)
{

	// render the scene.
	{
		NL3D_HAUTO_RENDER_SCENE_END
		_Scene.endPartRender(keepTrav);
	}

	if (updateWaitingInstancesFlag) updateWaitingInstances();

	// Must restore the matrix context, so 2D/3D interface not disturbed.
	if (restoreMatrixContextAfterRender) _DriverUser->restoreMatrixContext();
}


// ***************************************************************************
/*virtual*/ void CSceneUser::updateWaitingInstances(double ellapsedTime)
{
	_Scene.updateWaitingInstances(ellapsedTime);
	updateWaitingInstances();
}


// ***************************************************************************
void CSceneUser::updateWaitingInstances()
{
	// Update waiting instances
	{
		NL3D_HAUTO_ASYNC_IG

		// Done after the _Scene.render because in this method the instance are checked for creation
		std::map<UInstance*,CTransformShape*>::iterator it = _WaitingInstances.begin();
		while( it != _WaitingInstances.end() )
		{
			if( it->second != NULL )
			{
				it->first->attach (it->second);
				std::map<UInstance*,CTransformShape*>::iterator delIt = it;
				++it;
				_WaitingInstances.erase(delIt);
			}
			else
			{
				++it;
			}
		}
	}

	// update waiting instances groups;
	{
		NL3D_HAUTO_ASYNC_IG

		updateWaitingIG();
	}
}


void			CSceneUser::animate(TGlobalAnimationTime time)
{
	NL3D_HAUTO_RENDER_SCENE_ANIMATE;

	_Scene.animate(time);
}

// ***************************************************************************

void			CSceneUser::setCam(UCamera cam)
{
	NL3D_HAUTO_UI_SCENE;

	if(cam.empty())
		nlerror("setCam(): cannot set a NULL camera");
	CCamera *camera = cam.getObjectPtr();
	if( camera->getOwnerScene() != &_Scene)
		nlerror("setCam(): try to set a current camera not created from this scene");

	_Scene.setCam(camera);
}

// ***************************************************************************

UCamera			CSceneUser::getCam()
{
	NL3D_HAUTO_UI_SCENE;

	return UCamera (_Scene.getCam());
}

// ***************************************************************************

void			CSceneUser::setViewport(const class CViewport& viewport)
{
	NL3D_HAUTO_UI_SCENE;

	_Scene.setViewport(viewport);
}
CViewport		CSceneUser::getViewport()
{
	NL3D_HAUTO_UI_SCENE;

	return _Scene.getViewport();
}

UInstanceGroup	*CSceneUser::findCameraClusterSystemFromRay(UInstanceGroup *startClusterSystem,
			const NLMISC::CVector &startPos, NLMISC::CVector &endPos)
{
	NL3D_HAUTO_UI_SCENE;

	CInstanceGroupUser	*uig= dynamic_cast<CInstanceGroupUser*>(startClusterSystem);
	CInstanceGroup		*pIg= NULL;
	if(uig)
		pIg= &uig->_InstanceGroup;

	CInstanceGroup *resultIg= _Scene.findCameraClusterSystemFromRay(pIg, startPos, endPos);
	if(resultIg)
		return resultIg->getUserInterface();
	else
		return NULL;
}

// ***************************************************************************

UCamera			CSceneUser::createCamera()
{
	NL3D_HAUTO_ELT_SCENE;

	CTransform	*model= _Scene.createModel(CameraId);
	if (model)
	{
		CCamera *object = NLMISC::safe_cast<CCamera*>(model);
		object->setFrustum(UCamera::DefLx, UCamera::DefLy, UCamera::DefLzNear, UCamera::DefLzFar);
		return UCamera (object);
	}
	else
		return UCamera ();
}

// ***************************************************************************

void			CSceneUser::deleteCamera(UCamera &cam)
{
	NL3D_HAUTO_ELT_SCENE;

	CCamera		*object = cam.getObjectPtr();

	// The component is auto added/deleted to _Scene in ctor/dtor.
	_Scene.deleteModel (object);
	cam.detach ();
}

// ***************************************************************************

UInstance		CSceneUser::createInstance(const std::string &shapeName)
{
	NL3D_HAUTO_CREATE_INSTANCE;

	CTransformShape	*model= _Scene.createInstance(shapeName);
	return UInstance (model);
}

// ***************************************************************************

void CSceneUser::createInstanceAsync(const std::string &shapeName, UInstance *ppInstance, const NLMISC::CVector &position, uint selectedTexture)
{
	NL3D_HAUTO_CREATE_INSTANCE;

	_WaitingInstances[ppInstance] = NULL;
	_Scene.createInstanceAsync(shapeName,&_WaitingInstances[ppInstance], position, selectedTexture);
//		CTransform	*model= _Scene.createInstance(shapeName);
	// If not found, return NULL.
//		if(model==NULL)
//			return NULL;

//		if( dynamic_cast<CMeshInstance*>(model)==NULL )
//			nlerror("UScene::createInstance(): shape is not a mesh");

	// The component is auto added/deleted to _Scene in ctor/dtor.
//		return dynamic_cast<UInstance*>( _Transforms.insert(new CInstanceUser(&_Scene, model)) );
}

// ***************************************************************************

void			CSceneUser::deleteInstance(UInstance &inst)
{
	NL3D_HAUTO_ELT_SCENE;

	_Scene.deleteInstance (inst.getObjectPtr());
	inst.detach ();
}

// ***************************************************************************

void CSceneUser::createInstanceGroupAndAddToSceneAsync (const std::string &instanceGroup, UInstanceGroup **pIG, const NLMISC::CVector &pos, const NLMISC::CQuat &rot,
														uint selectedTexture, IAsyncLoadCallback *pCB)
{
	NL3D_HAUTO_ASYNC_IG;

	_WaitingIGs.push_front(CWaitingIG(pIG, pos, rot, selectedTexture, pCB));
	UInstanceGroup::createInstanceGroupAsync(instanceGroup, &(_WaitingIGs.begin()->IGToLoad));
	// this list updat will be performed at each render, see updateWaitingIG
}

void CSceneUser::stopCreatingAndAddingIG(UInstanceGroup **pIG)
{
	NL3D_HAUTO_ASYNC_IG;

	for(TWaitingIGList::iterator it = _WaitingIGs.begin(); it != _WaitingIGs.end(); ++it)
	{
		CWaitingIG &rWIG = *it;
		if (rWIG.CallerPtr == pIG)
		{
			if (rWIG.IGToLoad == NULL)
			{
				UInstanceGroup::stopCreateInstanceGroupAsync(pIG);
			}
			// Ig must be initialized
			else if (rWIG.IGToLoad != (UInstanceGroup*)-1)
			{
				switch(rWIG.IGToLoad->getAddToSceneState())
				{
					case UInstanceGroup::StateAdding:
						rWIG.IGToLoad->stopAddToSceneAsync();
					break;
					case UInstanceGroup::StateAdded:
						rWIG.IGToLoad->removeFromScene(*this);
						delete rWIG.IGToLoad;
					break;
					case UInstanceGroup::StateNotAdded:
						delete rWIG.IGToLoad;
					break;
					default:
					break;
				}
			}
			_WaitingIGs.erase(it);
			return;
		}
	}
}

void CSceneUser::deleteInstanceGroup(UInstanceGroup *pIG)
{
	delete pIG;
}

// ***************************************************************************

UTransform CSceneUser::createTransform()
{
	NL3D_HAUTO_ELT_SCENE;

	CTransform	*model= _Scene.createModel(TransformId);
	return UTransform (model);
}

// ***************************************************************************

void			CSceneUser::deleteTransform(UTransform &tr)
{
	NL3D_HAUTO_ELT_SCENE;

	_Scene.deleteModel (tr.getObjectPtr());
	tr.detach ();
}

// ***************************************************************************

USkeleton		CSceneUser::createSkeleton(const std::string &shapeName)
{
	NL3D_HAUTO_CREATE_SKELETON;

	CTransformShape *ts = _Scene.createInstance(shapeName);
	if (ts)
	{
		CSkeletonModel	*model= safe_cast<CSkeletonModel*> (ts);
		return USkeleton (model);
	}
	else
	{
		return USkeleton ();
	}
}

// ***************************************************************************

void			CSceneUser::deleteSkeleton(USkeleton &skel)
{
	NL3D_HAUTO_ELT_SCENE;

	// The component is auto added/deleted to _Scene in ctor/dtor.
	_Scene.deleteInstance (skel.getObjectPtr());
	skel.detach ();
}

// ***************************************************************************

ULandscape		*CSceneUser::createLandscape()
{
	NL3D_HAUTO_ELT_SCENE;

	// The component is auto added/deleted to _Scene in ctor/dtor.
	return _Landscapes.insert(new CLandscapeUser(&_Scene));
}
void			CSceneUser::deleteLandscape(ULandscape *land)
{
	NL3D_HAUTO_ELT_SCENE;

	// The component is auto added/deleted to _Scene in ctor/dtor.
	_Landscapes.erase((CLandscapeUser*) land);
}

UCloudScape *CSceneUser::createCloudScape()
{
	NL3D_HAUTO_ELT_SCENE;

	// The component is auto added/deleted to _Scene in ctor/dtor.
	return _CloudScapes.insert(new CCloudScapeUser(&_Scene));
}
void CSceneUser::deleteCloudScape(UCloudScape *cs)
{

	// The component is auto added/deleted to _Scene in ctor/dtor.
	_CloudScapes.erase((CCloudScapeUser*) cs);
}
/*

UInstanceGroup	*CSceneUser::createInstanceGroup (const std::string &instanceGroup)
{
	// Create the instance group
	CInstanceGroupUser *user=new CInstanceGroupUser;

	// Init the class
	if (!user->load (instanceGroup))
	{
		// Prb, erase it
		delete user;

		// Return error code
		return NULL;
	}

	// Insert the pointer in the pointer list
	_InstanceGroups.insert (user);

	// return the good value
	return user;
}

void			CSceneUser::deleteInstanceGroup (UInstanceGroup	*group)
{
	// The component is auto added/deleted to _Scene in ctor/dtor.
	_InstanceGroups.erase (dynamic_cast<CInstanceGroupUser*>(group));
}
*/

void CSceneUser::setToGlobalInstanceGroup(UInstanceGroup *pIG)
{
	NL3D_HAUTO_UI_SCENE;

	CInstanceGroupUser *pIGU = (CInstanceGroupUser*)pIG;
	pIGU->_InstanceGroup.setClusterSystemForInstances(_Scene.getGlobalInstanceGroup());
}

// ***************************************************************************
UVisualCollisionManager		*CSceneUser::createVisualCollisionManager()
{
	NL3D_HAUTO_ELT_SCENE;

	return _VisualCollisionManagers.insert(new CVisualCollisionManagerUser);
}
void						CSceneUser::deleteVisualCollisionManager(UVisualCollisionManager *mgr)
{
	NL3D_HAUTO_ELT_SCENE;

	CVisualCollisionManagerUser	*vcmUser= dynamic_cast<CVisualCollisionManagerUser*>(mgr);

	// if it was the one used for shadow receiving in this scene, then set NULL
	if(_Scene.getVisualCollisionManagerForShadow()==&vcmUser->getVCM())
		_Scene.setVisualCollisionManagerForShadow(NULL);

	// and delete it
	_VisualCollisionManagers.erase(vcmUser);
}


// ***************************************************************************
CSceneUser::CSceneUser(CDriverUser *drv, bool bSmallScene) : _Scene(bSmallScene)
{
	nlassert(drv);
	_DriverUser= drv;

	// init default Roots.
	_Scene.initDefaultRoots();

	// Set driver.
	_Scene.setDriver(_DriverUser->getDriver());

	// Set viewport
	_Scene.setViewport (CViewport());

	// init QuadGridClipManager
	_Scene.initQuadGridClipManager ();

	// Create default camera, and active!!
	setCam(createCamera());

	_WaterEnvMap = NULL;
}

CSceneUser::~CSceneUser()
{
	_VisualCollisionManagers.clear();
	_Landscapes.clear();
	_CloudScapes.clear();
	_Scene.release();
	_Scene.setDriver(NULL);
	_Scene.setCam(NULL);
	_DriverUser= NULL;
}

// ***************************************************************************
void		CSceneUser::setMaxSkeletonsInNotCLodForm(uint m)
{
	_Scene.setMaxSkeletonsInNotCLodForm(m);
}

// ***************************************************************************
uint		CSceneUser::getMaxSkeletonsInNotCLodForm() const
{
	return _Scene.getMaxSkeletonsInNotCLodForm();
}


// ***************************************************************************
void		CSceneUser::enableElementRender(TRenderFilter elt, bool state)
{
	_Scene.enableElementRender(elt, state);
}


// ***************************************************************************
void		CSceneUser::profileNextRender()
{
	_Scene.profileNextRender();
}
// ***************************************************************************
void		CSceneUser::getProfileResults(CBenchResults &results)
{
	// Fill profile results
	results= _Scene.BenchRes;
}

// ***************************************************************************
void		CSceneUser::profileQuadGridClipManager()
{
	_Scene.getClipTrav().getQuadGridClipManager()->profile();
}

// ***************************************************************************
uint CSceneUser::getNumFlareContexts() const
{
	return CScene::MaxNumFlareContexts;
}

// ***************************************************************************
void CSceneUser::setFlareContext(uint context)
{
	if (context >= CScene::MaxNumFlareContexts)
	{
		nlwarning("Invalid flare context");
		return;
	}
	_Scene.setFlareContext(context);
}

// ***************************************************************************
uint CSceneUser::getFlareContext() const
{
	return _Scene.getFlareContext();
}


// ***************************************************************************
uint			CSceneUser::getShadowMapTextureSize() const
{
	return _Scene.getShadowMapTextureSize();
}

// ***************************************************************************
void			CSceneUser::setShadowMapTextureSize(uint size)
{
	_Scene.setShadowMapTextureSize(size);
}

// ***************************************************************************
uint			CSceneUser::getShadowMapBlurSize() const
{
	return _Scene.getShadowMapBlurSize();
}

// ***************************************************************************
void			CSceneUser::setShadowMapBlurSize(uint bs)
{
	_Scene.setShadowMapBlurSize(bs);
}

// ***************************************************************************
void			CSceneUser::enableShadowPolySmooth(bool enable)
{
	_Scene.enableShadowPolySmooth(enable);
}

// ***************************************************************************
bool			CSceneUser::getEnableShadowPolySmooth() const
{
	return _Scene.getEnableShadowPolySmooth();
}

// ***************************************************************************
void			CSceneUser::setShadowMapDistFadeStart(float dist)
{
	_Scene.setShadowMapDistFadeStart(dist);
}
// ***************************************************************************
float			CSceneUser::getShadowMapDistFadeStart() const
{
	return _Scene.getShadowMapDistFadeStart();
}
// ***************************************************************************
void			CSceneUser::setShadowMapDistFadeEnd(float dist)
{
	_Scene.setShadowMapDistFadeEnd(dist);
}
// ***************************************************************************
float			CSceneUser::getShadowMapDistFadeEnd() const
{
	return _Scene.getShadowMapDistFadeEnd();
}
// ***************************************************************************
void			CSceneUser::setShadowMapMaxCasterInScreen(uint num)
{
	_Scene.setShadowMapMaxCasterInScreen(num);
}
// ***************************************************************************
uint			CSceneUser::getShadowMapMaxCasterInScreen() const
{
	return _Scene.getShadowMapMaxCasterInScreen();
}
// ***************************************************************************
void			CSceneUser::setShadowMapMaxCasterAround(uint num)
{
	_Scene.setShadowMapMaxCasterAround(num);
}
// ***************************************************************************
uint			CSceneUser::getShadowMapMaxCasterAround() const
{
	return _Scene.getShadowMapMaxCasterAround();
}
// ***************************************************************************
void			CSceneUser::setVisualCollisionManagerForShadow(UVisualCollisionManager *vcm)
{
	if(vcm==NULL)
		_Scene.setVisualCollisionManagerForShadow(NULL);
	else
	{
		CVisualCollisionManagerUser	*vcmUser= static_cast<CVisualCollisionManagerUser*>(vcm);
		_Scene.setVisualCollisionManagerForShadow(&vcmUser->getVCM());
	}
}
// ***************************************************************************
void CSceneUser::setWaterCallback(IWaterSurfaceAddedCallback *wcb)
{
	_Scene.setWaterCallback(wcb);
}
// ***************************************************************************
IWaterSurfaceAddedCallback *CSceneUser::getWaterCallback() const
{
	return _Scene.getWaterCallback();
}
// ***************************************************************************
void CSceneUser::setLandscapePolyDrawingCallback(ILandscapePolyDrawingCallback *lpd)
{
	_Scene.setLandscapePolyDrawingCallback(lpd);
}
// ***************************************************************************
ILandscapePolyDrawingCallback *CSceneUser::getLandscapePolyDrawingCallback() const
{
	return _Scene.getLandscapePolyDrawingCallback();
}
// ***************************************************************************
void CSceneUser::setupTransparencySorting(uint8 maxPriority /*=0*/,uint NbDistanceEntries /*=1024*/)
{
	_Scene.getRenderTrav().setupTransparencySorting(maxPriority, NbDistanceEntries);
}

// ***************************************************************************
void CSceneUser::setWaterEnvMap(UWaterEnvMap *waterEnvMap)
{
	if (waterEnvMap)
	{
		if (((CWaterEnvMapUser *) waterEnvMap)->EnvMap.Driver != _DriverUser)
		{
			nlwarning("Water envmap can only be set in a scene that was created from the same driver");
			return;
		}
	}
	_Scene.setWaterEnvMap(&((CWaterEnvMapUser *) waterEnvMap)->EnvMap);
	_WaterEnvMap = waterEnvMap;
}


// ***************************************************************************
void CSceneUser::updateWaterEnvMaps(TGlobalAnimationTime time)
{
	_Scene.updateWaterEnvMaps(time);
}




} // NL3D