Context Navigation

OgreSceneManager.cpp @ 692

Revision 692, 167.0 KB checked in by mattausch, 19 years ago (diff)
adding ogre 1.2 and dependencies

Rev	Line
[692]	1	/*
	2	-----------------------------------------------------------------------------
	3	This source file is part of OGRE
	4	(Object-oriented Graphics Rendering Engine)
	5	For the latest info, see http://ogre.sourceforge.net/
	6
	7	Copyright (c) 2000-2005 The OGRE Team
	8	Also see acknowledgements in Readme.html
	9
	10	This program is free software; you can redistribute it and/or modify it under
	11	the terms of the GNU Lesser General Public License as published by the Free Software
	12	Foundation; either version 2 of the License, or (at your option) any later
	13	version.
	14
	15	This program is distributed in the hope that it will be useful, but WITHOUT
	16	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	17	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
	18
	19	You should have received a copy of the GNU Lesser General Public License along with
	20	this program; if not, write to the Free Software Foundation, Inc., 59 Temple
	21	Place - Suite 330, Boston, MA 02111-1307, USA, or go to
	22	http://www.gnu.org/copyleft/lesser.txt.
	23	-----------------------------------------------------------------------------
	24	*/
	25	#include "OgreStableHeaders.h"
	26
	27	#include "OgreSceneManager.h"
	28
	29	#include "OgreCamera.h"
	30	#include "OgreRenderSystem.h"
	31	#include "OgreMeshManager.h"
	32	#include "OgreMesh.h"
	33	#include "OgreSubMesh.h"
	34	#include "OgreEntity.h"
	35	#include "OgreSubEntity.h"
	36	#include "OgreLight.h"
	37	#include "OgreMath.h"
	38	#include "OgreControllerManager.h"
	39	#include "OgreMaterialManager.h"
	40	#include "OgreAnimation.h"
	41	#include "OgreAnimationTrack.h"
	42	#include "OgreRenderQueueSortingGrouping.h"
	43	#include "OgreOverlay.h"
	44	#include "OgreOverlayManager.h"
	45	#include "OgreStringConverter.h"
	46	#include "OgreRenderQueueListener.h"
	47	#include "OgreBillboardSet.h"
	48	#include "OgrePass.h"
	49	#include "OgreTechnique.h"
	50	#include "OgreTextureUnitState.h"
	51	#include "OgreException.h"
	52	#include "OgreLogManager.h"
	53	#include "OgreHardwareBufferManager.h"
	54	#include "OgreRoot.h"
	55	#include "OgreSpotShadowFadePng.h"
	56	#include "OgreGpuProgramManager.h"
	57	#include "OgreGpuProgram.h"
	58	#include "OgreShadowVolumeExtrudeProgram.h"
	59	#include "OgreDataStream.h"
	60	#include "OgreStaticGeometry.h"
	61	#include "OgreHardwarePixelBuffer.h"
	62	#include "OgreManualObject.h"
	63	#include "OgreRenderQueueInvocation.h"
	64	#include "OgreBillboardChain.h"
	65	#include "OgreRibbonTrail.h"
	66	#include "OgreParticleSystemManager.h"
	67	// This class implements the most basic scene manager
	68
	69	#include <cstdio>
	70
	71	namespace Ogre {
	72
	73	//-----------------------------------------------------------------------
	74	uint32 SceneManager::WORLD_GEOMETRY_TYPE_MASK = 0x80000000;
	75	uint32 SceneManager::ENTITY_TYPE_MASK = 0x40000000;
	76	uint32 SceneManager::FX_TYPE_MASK = 0x20000000;
	77	uint32 SceneManager::STATICGEOMETRY_TYPE_MASK = 0x10000000;
	78	uint32 SceneManager::LIGHT_TYPE_MASK = 0x08000000;
	79	uint32 SceneManager::USER_TYPE_MASK_LIMIT = SceneManager::LIGHT_TYPE_MASK;
	80	//-----------------------------------------------------------------------
	81	SceneManager::SceneManager(const String& name) :
	82	mName(name),
	83	mRenderQueue(0),
	84	mSkyPlaneEntity(0),
	85	mSkyPlaneNode(0),
	86	mSkyDomeNode(0),
	87	mSkyBoxNode(0),
	88	mSkyPlaneEnabled(false),
	89	mSkyBoxEnabled(false),
	90	mSkyDomeEnabled(false),
	91	mFogMode(FOG_NONE),
	92	mSpecialCaseQueueMode(SCRQM_EXCLUDE),
	93	mWorldGeometryRenderQueue(RENDER_QUEUE_WORLD_GEOMETRY_1),
	94	mLastFrameNumber(0),
	95	mShadowCasterPlainBlackPass(0),
	96	mShadowReceiverPass(0),
	97	mDisplayNodes(false),
	98	mShowBoundingBoxes(false),
	99	mShadowTechnique(SHADOWTYPE_NONE),
	100	mDebugShadows(false),
	101	mShadowColour(ColourValue(0.25, 0.25, 0.25)),
	102	mShadowDebugPass(0),
	103	mShadowStencilPass(0),
	104	mShadowModulativePass(0),
	105	mShadowMaterialInitDone(false),
	106	mShadowIndexBufferSize(51200),
	107	mFullScreenQuad(0),
	108	mShadowDirLightExtrudeDist(10000),
	109	mIlluminationStage(IRS_NONE),
	110	mShadowTextureSize(512),
	111	mShadowTextureCount(1),
	112	mShadowTextureFormat(PF_X8R8G8B8),
	113	mShadowUseInfiniteFarPlane(true),
	114	mShadowCasterSphereQuery(0),
	115	mShadowCasterAABBQuery(0),
	116	mShadowFarDist(0),
	117	mShadowFarDistSquared(0),
	118	mShadowTextureOffset(0.6),
	119	mShadowTextureFadeStart(0.7),
	120	mShadowTextureFadeEnd(0.9),
	121	mShadowTextureSelfShadow(false),
	122	mShadowTextureCustomCasterPass(0),
	123	mShadowTextureCustomReceiverPass(0),
	124	mShadowTextureCasterVPDirty(false),
	125	mShadowTextureReceiverVPDirty(false),
	126	mVisibilityMask(0xFFFFFFFF),
	127	mFindVisibleObjects(true),
	128	mSuppressRenderStateChanges(false),
	129	mSuppressShadows(false)
	130	{
	131	// Root scene node
	132	mSceneRoot = new SceneNode(this, "root node");
	133	mSceneRoot->_notifyRootNode();
	134
	135	// init sky
	136	size_t i;
	137	for (i = 0; i < 6; ++i)
	138	{
	139	mSkyBoxEntity[i] = 0;
	140	}
	141	for (i = 0; i < 5; ++i)
	142	{
	143	mSkyDomeEntity[i] = 0;
	144	}
	145
	146	mShadowCasterQueryListener = new ShadowCasterSceneQueryListener(this);
	147
	148	Root *root = Root::getSingletonPtr();
	149	if (root)
	150	_setDestinationRenderSystem(root->getRenderSystem());
	151
	152	// Setup default queued renderable visitor
	153	mActiveQueuedRenderableVisitor = &mDefaultQueuedRenderableVisitor;
	154	}
	155	//-----------------------------------------------------------------------
	156	SceneManager::~SceneManager()
	157	{
	158	clearScene();
	159	destroyAllCameras();
	160
	161	// clear down movable object collection map
	162	for (MovableObjectCollectionMap::iterator i = mMovableObjectCollectionMap.begin();
	163	i != mMovableObjectCollectionMap.end(); ++i)
	164	{
	165	delete i->second;
	166	}
	167	mMovableObjectCollectionMap.clear();
	168
	169	delete mShadowCasterQueryListener;
	170	delete mSceneRoot;
	171	delete mFullScreenQuad;
	172	delete mShadowCasterSphereQuery;
	173	delete mShadowCasterAABBQuery;
	174	delete mRenderQueue;
	175	}
	176	//-----------------------------------------------------------------------
	177	RenderQueue* SceneManager::getRenderQueue(void)
	178	{
	179	if (!mRenderQueue)
	180	{
	181	initRenderQueue();
	182	}
	183	return mRenderQueue;
	184	}
	185	//-----------------------------------------------------------------------
	186	void SceneManager::initRenderQueue(void)
	187	{
	188	mRenderQueue = new RenderQueue();
	189	// init render queues that do not need shadows
	190	mRenderQueue->getQueueGroup(RENDER_QUEUE_BACKGROUND)->setShadowsEnabled(false);
	191	mRenderQueue->getQueueGroup(RENDER_QUEUE_OVERLAY)->setShadowsEnabled(false);
	192	mRenderQueue->getQueueGroup(RENDER_QUEUE_SKIES_EARLY)->setShadowsEnabled(false);
	193	mRenderQueue->getQueueGroup(RENDER_QUEUE_SKIES_LATE)->setShadowsEnabled(false);
	194	}
	195	//-----------------------------------------------------------------------
	196	void SceneManager::addSpecialCaseRenderQueue(uint8 qid)
	197	{
	198	mSpecialCaseQueueList.insert(qid);
	199	}
	200	//-----------------------------------------------------------------------
	201	void SceneManager::removeSpecialCaseRenderQueue(uint8 qid)
	202	{
	203	mSpecialCaseQueueList.erase(qid);
	204	}
	205	//-----------------------------------------------------------------------
	206	void SceneManager::clearSpecialCaseRenderQueues(void)
	207	{
	208	mSpecialCaseQueueList.clear();
	209	}
	210	//-----------------------------------------------------------------------
	211	void SceneManager::setSpecialCaseRenderQueueMode(SceneManager::SpecialCaseRenderQueueMode mode)
	212	{
	213	mSpecialCaseQueueMode = mode;
	214	}
	215	//-----------------------------------------------------------------------
	216	SceneManager::SpecialCaseRenderQueueMode SceneManager::getSpecialCaseRenderQueueMode(void)
	217	{
	218	return mSpecialCaseQueueMode;
	219	}
	220	//-----------------------------------------------------------------------
	221	bool SceneManager::isRenderQueueToBeProcessed(uint8 qid)
	222	{
	223	bool inList = mSpecialCaseQueueList.find(qid) != mSpecialCaseQueueList.end();
	224	return (inList && mSpecialCaseQueueMode == SCRQM_INCLUDE)
	225	\|\| (!inList && mSpecialCaseQueueMode == SCRQM_EXCLUDE);
	226	}
	227	//-----------------------------------------------------------------------
	228	void SceneManager::setWorldGeometryRenderQueue(uint8 qid)
	229	{
	230	mWorldGeometryRenderQueue = qid;
	231	}
	232	//-----------------------------------------------------------------------
	233	uint8 SceneManager::getWorldGeometryRenderQueue(void)
	234	{
	235	return mWorldGeometryRenderQueue;
	236	}
	237	//-----------------------------------------------------------------------
	238	Camera* SceneManager::createCamera(const String& name)
	239	{
	240	// Check name not used
	241	if (mCameras.find(name) != mCameras.end())
	242	{
	243	OGRE_EXCEPT(
	244	Exception::ERR_DUPLICATE_ITEM,
	245	"A camera with the name " + name + " already exists",
	246	"SceneManager::createCamera" );
	247	}
	248
	249	Camera *c = new Camera(name, this);
	250	mCameras.insert(CameraList::value_type(name, c));
	251
	252
	253	return c;
	254	}
	255
	256	//-----------------------------------------------------------------------
	257	Camera* SceneManager::getCamera(const String& name)
	258	{
	259	CameraList::iterator i = mCameras.find(name);
	260	if (i == mCameras.end())
	261	{
	262	OGRE_EXCEPT( Exception::ERR_ITEM_NOT_FOUND,
	263	"Cannot find Camera with name " + name,
	264	"SceneManager::getCamera");
	265	}
	266	else
	267	{
	268	return i->second;
	269	}
	270	}
	271
	272	//-----------------------------------------------------------------------
	273	void SceneManager::destroyCamera(Camera *cam)
	274	{
	275	// Find in list
	276	CameraList::iterator i = mCameras.begin();
	277	for (; i != mCameras.end(); ++i)
	278	{
	279	if (i->second == cam)
	280	{
	281	mCameras.erase(i);
	282	// notify render targets
	283	mDestRenderSystem->_notifyCameraRemoved(cam);
	284	delete cam;
	285	break;
	286	}
	287	}
	288
	289	}
	290
	291	//-----------------------------------------------------------------------
	292	void SceneManager::destroyCamera(const String& name)
	293	{
	294	// Find in list
	295	CameraList::iterator i = mCameras.find(name);
	296	if (i != mCameras.end())
	297	{
	298	// Notify render system
	299	mDestRenderSystem->_notifyCameraRemoved(i->second);
	300	delete i->second;
	301	mCameras.erase(i);
	302	}
	303
	304	}
	305
	306	//-----------------------------------------------------------------------
	307	void SceneManager::destroyAllCameras(void)
	308	{
	309
	310	CameraList::iterator i = mCameras.begin();
	311	for (; i != mCameras.end(); ++i)
	312	{
	313	// Notify render system
	314	mDestRenderSystem->_notifyCameraRemoved(i->second);
	315	delete i->second;
	316	}
	317	mCameras.clear();
	318	}
	319	//-----------------------------------------------------------------------
	320	Light* SceneManager::createLight(const String& name)
	321	{
	322	return static_cast<Light*>(
	323	createMovableObject(name, LightFactory::FACTORY_TYPE_NAME));
	324	}
	325	//-----------------------------------------------------------------------
	326	Light* SceneManager::getLight(const String& name)
	327	{
	328	return static_cast<Light*>(
	329	getMovableObject(name, LightFactory::FACTORY_TYPE_NAME));
	330	}
	331	//-----------------------------------------------------------------------
	332	void SceneManager::destroyLight(Light *l)
	333	{
	334	destroyMovableObject(l);
	335	}
	336	//-----------------------------------------------------------------------
	337	void SceneManager::destroyLight(const String& name)
	338	{
	339	destroyMovableObject(name, LightFactory::FACTORY_TYPE_NAME);
	340	}
	341	//-----------------------------------------------------------------------
	342	void SceneManager::destroyAllLights(void)
	343	{
	344	destroyAllMovableObjectsByType(LightFactory::FACTORY_TYPE_NAME);
	345	}
	346	//-----------------------------------------------------------------------
	347	bool SceneManager::lightLess::operator()(const Light* a, const Light* b) const
	348	{
	349	return a->tempSquareDist < b->tempSquareDist;
	350	}
	351	//-----------------------------------------------------------------------
	352	void SceneManager::_populateLightList(const Vector3& position, Real radius,
	353	LightList& destList)
	354	{
	355	// Really basic trawl of the lights, then sort
	356	// Subclasses could do something smarter
	357	destList.clear();
	358
	359	MovableObjectIterator it =
	360	getMovableObjectIterator(LightFactory::FACTORY_TYPE_NAME);
	361
	362	while(it.hasMoreElements())
	363	{
	364	Light* lt = static_cast<Light*>(it.getNext());
	365	if (lt->isVisible())
	366	{
	367	if (lt->getType() == Light::LT_DIRECTIONAL)
	368	{
	369	// No distance
	370	lt->tempSquareDist = 0.0f;
	371	destList.push_back(lt);
	372	}
	373	else
	374	{
	375	// Calc squared distance
	376	lt->tempSquareDist = (lt->getDerivedPosition() - position).squaredLength();
	377	// only add in-range lights
	378	Real range = lt->getAttenuationRange();
	379	Real maxDist = range + radius;
	380	if (lt->tempSquareDist <= Math::Sqr(maxDist))
	381	{
	382	destList.push_back(lt);
	383	}
	384	}
	385	}
	386	}
	387
	388	// Sort (stable to guarantee ordering on directional lights)
	389	std::stable_sort(destList.begin(), destList.end(), lightLess());
	390
	391
	392	}
	393	//-----------------------------------------------------------------------
	394	Entity* SceneManager::createEntity(const String& entityName, PrefabType ptype)
	395	{
	396	switch (ptype)
	397	{
	398	case PT_PLANE:
	399	return createEntity(entityName, "Prefab_Plane");
	400
	401	break;
	402	}
	403
	404	OGRE_EXCEPT( Exception::ERR_ITEM_NOT_FOUND,
	405	"Unknown prefab type for entity " + entityName,
	406	"SceneManager::createEntity");
	407	}
	408
	409	//-----------------------------------------------------------------------
	410	Entity* SceneManager::createEntity(
	411	const String& entityName,
	412	const String& meshName )
	413	{
	414	// delegate to factory implementation
	415	NameValuePairList params;
	416	params["mesh"] = meshName;
	417	return static_cast<Entity*>(
	418	createMovableObject(entityName, EntityFactory::FACTORY_TYPE_NAME,
	419	&params));
	420
	421	}
	422
	423	//-----------------------------------------------------------------------
	424	Entity* SceneManager::getEntity(const String& name)
	425	{
	426	return static_cast<Entity*>(
	427	getMovableObject(name, EntityFactory::FACTORY_TYPE_NAME));
	428	}
	429
	430	//-----------------------------------------------------------------------
	431	void SceneManager::destroyEntity(Entity *e)
	432	{
	433	destroyMovableObject(e);
	434	}
	435
	436	//-----------------------------------------------------------------------
	437	void SceneManager::destroyEntity(const String& name)
	438	{
	439	destroyMovableObject(name, EntityFactory::FACTORY_TYPE_NAME);
	440
	441	}
	442
	443	//-----------------------------------------------------------------------
	444	void SceneManager::destroyAllEntities(void)
	445	{
	446
	447	destroyAllMovableObjectsByType(EntityFactory::FACTORY_TYPE_NAME);
	448	}
	449
	450	//-----------------------------------------------------------------------
	451	void SceneManager::destroyAllBillboardSets(void)
	452	{
	453	destroyAllMovableObjectsByType(BillboardSetFactory::FACTORY_TYPE_NAME);
	454	}
	455	//-----------------------------------------------------------------------
	456	ManualObject* SceneManager::createManualObject(const String& name)
	457	{
	458	return static_cast<ManualObject*>(
	459	createMovableObject(name, ManualObjectFactory::FACTORY_TYPE_NAME));
	460	}
	461	//-----------------------------------------------------------------------
	462	ManualObject* SceneManager::getManualObject(const String& name)
	463	{
	464	return static_cast<ManualObject*>(
	465	getMovableObject(name, ManualObjectFactory::FACTORY_TYPE_NAME));
	466
	467	}
	468	//-----------------------------------------------------------------------
	469	void SceneManager::destroyManualObject(ManualObject* obj)
	470	{
	471	destroyMovableObject(obj);
	472	}
	473	//-----------------------------------------------------------------------
	474	void SceneManager::destroyManualObject(const String& name)
	475	{
	476	destroyMovableObject(name, ManualObjectFactory::FACTORY_TYPE_NAME);
	477	}
	478	//-----------------------------------------------------------------------
	479	void SceneManager::destroyAllManualObjects(void)
	480	{
	481	destroyAllMovableObjectsByType(ManualObjectFactory::FACTORY_TYPE_NAME);
	482	}
	483	//-----------------------------------------------------------------------
	484	BillboardChain* SceneManager::createBillboardChain(const String& name)
	485	{
	486	return static_cast<BillboardChain*>(
	487	createMovableObject(name, BillboardChainFactory::FACTORY_TYPE_NAME));
	488	}
	489	//-----------------------------------------------------------------------
	490	BillboardChain* SceneManager::getBillboardChain(const String& name)
	491	{
	492	return static_cast<BillboardChain*>(
	493	getMovableObject(name, BillboardChainFactory::FACTORY_TYPE_NAME));
	494
	495	}
	496	//-----------------------------------------------------------------------
	497	void SceneManager::destroyBillboardChain(BillboardChain* obj)
	498	{
	499	destroyMovableObject(obj);
	500	}
	501	//-----------------------------------------------------------------------
	502	void SceneManager::destroyBillboardChain(const String& name)
	503	{
	504	destroyMovableObject(name, BillboardChainFactory::FACTORY_TYPE_NAME);
	505	}
	506	//-----------------------------------------------------------------------
	507	void SceneManager::destroyAllBillboardChains(void)
	508	{
	509	destroyAllMovableObjectsByType(BillboardChainFactory::FACTORY_TYPE_NAME);
	510	}
	511	//-----------------------------------------------------------------------
	512	RibbonTrail* SceneManager::createRibbonTrail(const String& name)
	513	{
	514	return static_cast<RibbonTrail*>(
	515	createMovableObject(name, RibbonTrailFactory::FACTORY_TYPE_NAME));
	516	}
	517	//-----------------------------------------------------------------------
	518	RibbonTrail* SceneManager::getRibbonTrail(const String& name)
	519	{
	520	return static_cast<RibbonTrail*>(
	521	getMovableObject(name, RibbonTrailFactory::FACTORY_TYPE_NAME));
	522
	523	}
	524	//-----------------------------------------------------------------------
	525	void SceneManager::destroyRibbonTrail(RibbonTrail* obj)
	526	{
	527	destroyMovableObject(obj);
	528	}
	529	//-----------------------------------------------------------------------
	530	void SceneManager::destroyRibbonTrail(const String& name)
	531	{
	532	destroyMovableObject(name, RibbonTrailFactory::FACTORY_TYPE_NAME);
	533	}
	534	//-----------------------------------------------------------------------
	535	void SceneManager::destroyAllRibbonTrails(void)
	536	{
	537	destroyAllMovableObjectsByType(RibbonTrailFactory::FACTORY_TYPE_NAME);
	538	}
	539	//-----------------------------------------------------------------------
	540	ParticleSystem* SceneManager::createParticleSystem(const String& name,
	541	const String& templateName)
	542	{
	543	NameValuePairList params;
	544	params["templateName"] = templateName;
	545
	546	return static_cast<ParticleSystem*>(
	547	createMovableObject(name, ParticleSystemFactory::FACTORY_TYPE_NAME,
	548	&params));
	549	}
	550	//-----------------------------------------------------------------------
	551	ParticleSystem* SceneManager::createParticleSystem(const String& name,
	552	size_t quota, const String& group)
	553	{
	554	NameValuePairList params;
	555	params["quota"] = StringConverter::toString(quota);
	556	params["resourceGroup"] = group;
	557
	558	return static_cast<ParticleSystem*>(
	559	createMovableObject(name, ParticleSystemFactory::FACTORY_TYPE_NAME,
	560	&params));
	561	}
	562	//-----------------------------------------------------------------------
	563	ParticleSystem* SceneManager::getParticleSystem(const String& name)
	564	{
	565	return static_cast<ParticleSystem*>(
	566	getMovableObject(name, ParticleSystemFactory::FACTORY_TYPE_NAME));
	567
	568	}
	569	//-----------------------------------------------------------------------
	570	void SceneManager::destroyParticleSystem(ParticleSystem* obj)
	571	{
	572	destroyMovableObject(obj);
	573	}
	574	//-----------------------------------------------------------------------
	575	void SceneManager::destroyParticleSystem(const String& name)
	576	{
	577	destroyMovableObject(name, ParticleSystemFactory::FACTORY_TYPE_NAME);
	578	}
	579	//-----------------------------------------------------------------------
	580	void SceneManager::destroyAllParticleSystems(void)
	581	{
	582	destroyAllMovableObjectsByType(ParticleSystemFactory::FACTORY_TYPE_NAME);
	583	}
	584	//-----------------------------------------------------------------------
	585	void SceneManager::clearScene(void)
	586	{
	587	destroyAllStaticGeometry();
	588	destroyAllMovableObjects();
	589
	590	// Clear root node of all children
	591	mSceneRoot->removeAllChildren();
	592	mSceneRoot->detachAllObjects();
	593
	594	// Delete all SceneNodes, except root that is
	595	for (SceneNodeList::iterator i = mSceneNodes.begin();
	596	i != mSceneNodes.end(); ++i)
	597	{
	598	delete i->second;
	599	}
	600	mSceneNodes.clear();
	601	mAutoTrackingSceneNodes.clear();
	602
	603
	604
	605	// Clear animations
	606	destroyAllAnimations();
	607
	608	// Remove sky nodes since they've been deleted
	609	mSkyBoxNode = mSkyPlaneNode = mSkyDomeNode = 0;
	610	mSkyBoxEnabled = mSkyPlaneEnabled = mSkyDomeEnabled = false;
	611
	612	// Clear render queue, empty completely
	613	if (mRenderQueue)
	614	mRenderQueue->clear(true);
	615
	616	}
	617	//-----------------------------------------------------------------------
	618	SceneNode* SceneManager::createSceneNode(void)
	619	{
	620	SceneNode* sn = new SceneNode(this);
	621	assert(mSceneNodes.find(sn->getName()) == mSceneNodes.end());
	622	mSceneNodes[sn->getName()] = sn;
	623	return sn;
	624	}
	625	//-----------------------------------------------------------------------
	626	SceneNode* SceneManager::createSceneNode(const String& name)
	627	{
	628	// Check name not used
	629	if (mSceneNodes.find(name) != mSceneNodes.end())
	630	{
	631	OGRE_EXCEPT(
	632	Exception::ERR_DUPLICATE_ITEM,
	633	"A scene node with the name " + name + " already exists",
	634	"SceneManager::createSceneNode" );
	635	}
	636
	637	SceneNode* sn = new SceneNode(this, name);
	638	mSceneNodes[sn->getName()] = sn;
	639	return sn;
	640	}
	641	//-----------------------------------------------------------------------
	642	void SceneManager::destroySceneNode(const String& name)
	643	{
	644	SceneNodeList::iterator i = mSceneNodes.find(name);
	645
	646	if (i == mSceneNodes.end())
	647	{
	648	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "SceneNode '" + name + "' not found.",
	649	"SceneManager::destroySceneNode");
	650	}
	651
	652	// Find any scene nodes which are tracking this node, and turn them off
	653	AutoTrackingSceneNodes::iterator ai, aiend;
	654	aiend = mAutoTrackingSceneNodes.end();
	655	for (ai = mAutoTrackingSceneNodes.begin(); ai != aiend; )
	656	{
	657	// Pre-increment incase we delete
	658	AutoTrackingSceneNodes::iterator curri = ai++;
	659	SceneNode* n = *curri;
	660	// Tracking this node
	661	if (n->getAutoTrackTarget() == i->second)
	662	{
	663	// turn off, this will notify SceneManager to remove
	664	n->setAutoTracking(false);
	665	}
	666	// node is itself a tracker
	667	else if (n == i->second)
	668	{
	669	mAutoTrackingSceneNodes.erase(curri);
	670	}
	671	}
	672
	673	// detach from parent (don't do this in destructor since bulk destruction
	674	// behaves differently)
	675	Node* parentNode = i->second->getParent();
	676	if (parentNode)
	677	{
	678	parentNode->removeChild(i->second);
	679	}
	680	delete i->second;
	681	mSceneNodes.erase(i);
	682	}
	683	//-----------------------------------------------------------------------
	684	SceneNode* SceneManager::getRootSceneNode(void) const
	685	{
	686	return mSceneRoot;
	687	}
	688	//-----------------------------------------------------------------------
	689	SceneNode* SceneManager::getSceneNode(const String& name) const
	690	{
	691	SceneNodeList::const_iterator i = mSceneNodes.find(name);
	692
	693	if (i == mSceneNodes.end())
	694	{
	695	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "SceneNode '" + name + "' not found.",
	696	"SceneManager::getSceneNode");
	697	}
	698
	699	return i->second;
	700
	701	}
	702	//-----------------------------------------------------------------------
	703	const Pass* SceneManager::_setPass(const Pass* pass, bool evenIfSuppressed)
	704	{
	705	if (!mSuppressRenderStateChanges \|\| evenIfSuppressed)
	706	{
	707	if (mIlluminationStage == IRS_RENDER_TO_TEXTURE)
	708	{
	709	// Derive a special shadow caster pass from this one
	710	pass = deriveShadowCasterPass(pass);
	711	}
	712	else if (mIlluminationStage == IRS_RENDER_RECEIVER_PASS)
	713	{
	714	pass = deriveShadowReceiverPass(pass);
	715	}
	716
	717	// TEST
	718	/*
	719	LogManager::getSingleton().logMessage("BEGIN PASS " + StringConverter::toString(pass->getIndex()) +
	720	" of " + pass->getParent()->getParent()->getName());
	721	*/
	722	bool passSurfaceAndLightParams = true;
	723
	724	if (pass->hasVertexProgram())
	725	{
	726	mDestRenderSystem->bindGpuProgram(pass->getVertexProgram()->_getBindingDelegate());
	727	// bind parameters later since they can be per-object
	728	// does the vertex program want surface and light params passed to rendersystem?
	729	passSurfaceAndLightParams = pass->getVertexProgram()->getPassSurfaceAndLightStates();
	730	}
	731	else
	732	{
	733	// Unbind program?
	734	if (mDestRenderSystem->isGpuProgramBound(GPT_VERTEX_PROGRAM))
	735	{
	736	mDestRenderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM);
	737	}
	738	// Set fixed-function vertex parameters
	739	}
	740
	741	if (passSurfaceAndLightParams)
	742	{
	743	// Set surface reflectance properties, only valid if lighting is enabled
	744	if (pass->getLightingEnabled())
	745	{
	746	mDestRenderSystem->_setSurfaceParams(
	747	pass->getAmbient(),
	748	pass->getDiffuse(),
	749	pass->getSpecular(),
	750	pass->getSelfIllumination(),
	751	pass->getShininess(),
	752	pass->getVertexColourTracking() );
	753	}
	754
	755	// Dynamic lighting enabled?
	756	mDestRenderSystem->setLightingEnabled(pass->getLightingEnabled());
	757	}
	758
	759	// Using a fragment program?
	760	if (pass->hasFragmentProgram())
	761	{
	762	mDestRenderSystem->bindGpuProgram(
	763	pass->getFragmentProgram()->_getBindingDelegate());
	764	// bind parameters later since they can be per-object
	765	}
	766	else
	767	{
	768	// Unbind program?
	769	if (mDestRenderSystem->isGpuProgramBound(GPT_FRAGMENT_PROGRAM))
	770	{
	771	mDestRenderSystem->unbindGpuProgram(GPT_FRAGMENT_PROGRAM);
	772	}
	773
	774	// Set fixed-function fragment settings
	775	}
	776
	777	/* We need sets fog properties always. In D3D, it applies to shaders prior
	778	to version vs_3_0 and ps_3_0. And in OGL, it applies to "ARB_fog_XXX" in
	779	fragment program, and in other ways, them maybe access by gpu program via
	780	"state.fog.XXX".
	781	*/
	782	// New fog params can either be from scene or from material
	783	FogMode newFogMode;
	784	ColourValue newFogColour;
	785	Real newFogStart, newFogEnd, newFogDensity;
	786	if (pass->getFogOverride())
	787	{
	788	// New fog params from material
	789	newFogMode = pass->getFogMode();
	790	newFogColour = pass->getFogColour();
	791	newFogStart = pass->getFogStart();
	792	newFogEnd = pass->getFogEnd();
	793	newFogDensity = pass->getFogDensity();
	794	}
	795	else
	796	{
	797	// New fog params from scene
	798	newFogMode = mFogMode;
	799	newFogColour = mFogColour;
	800	newFogStart = mFogStart;
	801	newFogEnd = mFogEnd;
	802	newFogDensity = mFogDensity;
	803	}
	804	// Tell params about current fog
	805	mAutoParamDataSource.setFog(
	806	newFogMode, newFogColour, newFogDensity, newFogStart, newFogEnd);
	807	mDestRenderSystem->_setFog(
	808	newFogMode, newFogColour, newFogDensity, newFogStart, newFogEnd);
	809
	810	// The rest of the settings are the same no matter whether we use programs or not
	811
	812	// Set scene blending
	813	mDestRenderSystem->_setSceneBlending(
	814	pass->getSourceBlendFactor(), pass->getDestBlendFactor());
	815
	816	// Set point parameters
	817	mDestRenderSystem->_setPointParameters(
	818	pass->getPointSize(),
	819	pass->isPointAttenuationEnabled(),
	820	pass->getPointAttenuationConstant(),
	821	pass->getPointAttenuationLinear(),
	822	pass->getPointAttenuationQuadratic(),
	823	pass->getPointMinSize(),
	824	pass->getPointMaxSize());
	825
	826	mDestRenderSystem->_setPointSpritesEnabled(pass->getPointSpritesEnabled());
	827
	828	// Texture unit settings
	829
	830	Pass::ConstTextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
	831	size_t unit = 0;
	832	while(texIter.hasMoreElements())
	833	{
	834	TextureUnitState* pTex = texIter.getNext();
	835	mDestRenderSystem->_setTextureUnitSettings(unit, *pTex);
	836	++unit;
	837	}
	838	// Disable remaining texture units
	839	mDestRenderSystem->_disableTextureUnitsFrom(pass->getNumTextureUnitStates());
	840
	841	// Set up non-texture related material settings
	842	// Depth buffer settings
	843	mDestRenderSystem->_setDepthBufferFunction(pass->getDepthFunction());
	844	mDestRenderSystem->_setDepthBufferCheckEnabled(pass->getDepthCheckEnabled());
	845	mDestRenderSystem->_setDepthBufferWriteEnabled(pass->getDepthWriteEnabled());
	846	mDestRenderSystem->_setDepthBias(pass->getDepthBias());
	847	// Alpha-reject settings
	848	mDestRenderSystem->_setAlphaRejectSettings(
	849	pass->getAlphaRejectFunction(), pass->getAlphaRejectValue());
	850	// Set colour write mode
	851	// Right now we only use on/off, not per-channel
	852	bool colWrite = pass->getColourWriteEnabled();
	853	mDestRenderSystem->_setColourBufferWriteEnabled(colWrite, colWrite, colWrite, colWrite);
	854	// Culling mode
	855	mDestRenderSystem->_setCullingMode(pass->getCullingMode());
	856	// Shading
	857	mDestRenderSystem->setShadingType(pass->getShadingMode());
	858	// Polygon mode
	859	mDestRenderSystem->_setPolygonMode(pass->getPolygonMode());
	860
	861	// set pass number
	862	mAutoParamDataSource.setPassNumber( pass->getIndex() );
	863	}
	864
	865	return pass;
	866	}
	867	//-----------------------------------------------------------------------
	868	void SceneManager::prepareRenderQueue(void)
	869	{
	870	RenderQueue* q = getRenderQueue();
	871	// Clear the render queue
	872	q->clear();
	873
	874	// Prep the ordering options
	875
	876	// If we're using a custom render squence, define based on that
	877	RenderQueueInvocationSequence* seq =
	878	mCurrentViewport->_getRenderQueueInvocationSequence();
	879	if (seq)
	880	{
	881	// Iterate once to crate / reset all
	882	RenderQueueInvocationIterator invokeIt = seq->iterator();
	883	while (invokeIt.hasMoreElements())
	884	{
	885	RenderQueueInvocation* invocation = invokeIt.getNext();
	886	RenderQueueGroup* group =
	887	q->getQueueGroup(invocation->getRenderQueueGroupID());
	888	group->resetOrganisationModes();
	889	}
	890	// Iterate again to build up options (may be more than one)
	891	invokeIt = seq->iterator();
	892	while (invokeIt.hasMoreElements())
	893	{
	894	RenderQueueInvocation* invocation = invokeIt.getNext();
	895	RenderQueueGroup* group =
	896	q->getQueueGroup(invocation->getRenderQueueGroupID());
	897	group->addOrganisationMode(invocation->getSolidsOrganisation());
	898	// also set splitting options
	899	updateRenderQueueGroupSplitOptions(group, invocation->getSuppressShadows(),
	900	invocation->getSuppressRenderStateChanges());
	901	}
	902	}
	903	else
	904	{
	905	// Default all the queue groups that are there, new ones will be created
	906	// with defaults too
	907	RenderQueue::QueueGroupIterator groupIter = q->_getQueueGroupIterator();
	908	while (groupIter.hasMoreElements())
	909	{
	910	RenderQueueGroup* g = groupIter.getNext();
	911	g->defaultOrganisationMode();
	912	}
	913	// Global split options
	914	updateRenderQueueSplitOptions();
	915	}
	916
	917	}
	918	//-----------------------------------------------------------------------
	919	void SceneManager::_renderScene(Camera* camera, Viewport* vp, bool includeOverlays)
	920	{
	921	Root::getSingleton()._setCurrentSceneManager(this);
	922	mActiveQueuedRenderableVisitor->targetSceneMgr = this;
	923
	924	if (isShadowTechniqueInUse())
	925	{
	926	// Prepare shadow materials
	927	initShadowVolumeMaterials();
	928	}
	929
	930	// Perform a quick pre-check to see whether we should override far distance
	931	// When using stencil volumes we have to use infinite far distance
	932	// to prevent dark caps getting clipped
	933	if (isShadowTechniqueStencilBased() &&
	934	camera->getProjectionType() == PT_PERSPECTIVE &&
	935	camera->getFarClipDistance() != 0 &&
	936	mDestRenderSystem->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE) &&
	937	mShadowUseInfiniteFarPlane)
	938	{
	939	// infinite far distance
	940	camera->setFarClipDistance(0);
	941	}
	942
	943	mCameraInProgress = camera;
	944
	945
	946	// Update controllers
	947	ControllerManager::getSingleton().updateAllControllers();
	948
	949	// Update the scene, only do this once per frame
	950	unsigned long thisFrameNumber = Root::getSingleton().getCurrentFrameNumber();
	951	if (thisFrameNumber != mLastFrameNumber)
	952	{
	953	// Update animations
	954	_applySceneAnimations();
	955	mLastFrameNumber = thisFrameNumber;
	956	}
	957
	958	// Update scene graph for this camera (can happen multiple times per frame)
	959	_updateSceneGraph(camera);
	960
	961	// Auto-track nodes
	962	AutoTrackingSceneNodes::iterator atsni, atsniend;
	963	atsniend = mAutoTrackingSceneNodes.end();
	964	for (atsni = mAutoTrackingSceneNodes.begin(); atsni != atsniend; ++atsni)
	965	{
	966	(*atsni)->_autoTrack();
	967	}
	968	// Auto-track camera if required
	969	camera->_autoTrack();
	970
	971
	972	// Are we using any shadows at all?
	973	if (isShadowTechniqueInUse() &&
	974	mIlluminationStage != IRS_RENDER_TO_TEXTURE &&
	975	vp->getShadowsEnabled() &&
	976	mFindVisibleObjects)
	977	{
	978	// Locate any lights which could be affecting the frustum
	979	findLightsAffectingFrustum(camera);
	980	if (isShadowTechniqueTextureBased())
	981	{
	982	// *******
	983	// WARNING
	984	// *******
	985	// This call will result in re-entrant calls to this method
	986	// therefore anything which comes before this is NOT
	987	// guaranteed persistent. Make sure that anything which
	988	// MUST be specific to this camera / target is done
	989	// AFTER THIS POINT
	990	prepareShadowTextures(camera, vp);
	991	// reset the cameras because of the re-entrant call
	992	mCameraInProgress = camera;
	993	}
	994	}
	995
	996	// Invert vertex winding?
	997	if (camera->isReflected())
	998	{
	999	mDestRenderSystem->setInvertVertexWinding(true);
	1000	}
	1001	else
	1002	{
	1003	mDestRenderSystem->setInvertVertexWinding(false);
	1004	}
	1005
	1006	// Tell params about viewport
	1007	mAutoParamDataSource.setCurrentViewport(vp);
	1008	// Set the viewport
	1009	setViewport(vp);
	1010
	1011	// Tell params about camera
	1012	mAutoParamDataSource.setCurrentCamera(camera);
	1013	// Set autoparams for finite dir light extrusion
	1014	mAutoParamDataSource.setShadowDirLightExtrusionDistance(mShadowDirLightExtrudeDist);
	1015
	1016	// Tell params about current ambient light
	1017	mAutoParamDataSource.setAmbientLightColour(mAmbientLight);
	1018	// Tell rendersystem
	1019	mDestRenderSystem->setAmbientLight(mAmbientLight.r, mAmbientLight.g, mAmbientLight.b);
	1020
	1021	// Tell params about render target
	1022	mAutoParamDataSource.setCurrentRenderTarget(vp->getTarget());
	1023
	1024
	1025	// Set camera window clipping planes (if any)
	1026	if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_USER_CLIP_PLANES))
	1027	{
	1028	if (camera->isWindowSet())
	1029	{
	1030	const std::vector<Plane>& planeList =
	1031	camera->getWindowPlanes();
	1032	for (ushort i = 0; i < 4; ++i)
	1033	{
	1034	mDestRenderSystem->enableClipPlane(i, true);
	1035	mDestRenderSystem->setClipPlane(i, planeList[i]);
	1036	}
	1037	}
	1038	else
	1039	{
	1040	for (ushort i = 0; i < 4; ++i)
	1041	{
	1042	mDestRenderSystem->enableClipPlane(i, false);
	1043	}
	1044	}
	1045	}
	1046
	1047	// Prepare render queue for receiving new objects
	1048	prepareRenderQueue();
	1049
	1050	if (mFindVisibleObjects)
	1051	{
	1052	// Parse the scene and tag visibles
	1053	_findVisibleObjects(camera,
	1054	mIlluminationStage == IRS_RENDER_TO_TEXTURE? true : false);
	1055	}
	1056	// Add overlays, if viewport deems it
	1057	if (vp->getOverlaysEnabled() && mIlluminationStage != IRS_RENDER_TO_TEXTURE)
	1058	{
	1059	OverlayManager::getSingleton()._queueOverlaysForRendering(camera, getRenderQueue(), vp);
	1060	}
	1061	// Queue skies, if viewport seems it
	1062	if (vp->getSkiesEnabled() && mFindVisibleObjects && mIlluminationStage != IRS_RENDER_TO_TEXTURE)
	1063	{
	1064	_queueSkiesForRendering(camera);
	1065	}
	1066
	1067
	1068	mDestRenderSystem->_beginGeometryCount();
	1069	// Begin the frame
	1070	mDestRenderSystem->_beginFrame();
	1071
	1072	// Set rasterisation mode
	1073	mDestRenderSystem->_setPolygonMode(camera->getPolygonMode());
	1074
	1075	// Set initial camera state
	1076	mDestRenderSystem->_setProjectionMatrix(mCameraInProgress->getProjectionMatrixRS());
	1077	mDestRenderSystem->_setViewMatrix(mCameraInProgress->getViewMatrix(true));
	1078
	1079	// Render scene content
	1080	_renderVisibleObjects();
	1081
	1082	// End frame
	1083	mDestRenderSystem->_endFrame();
	1084
	1085	// Notify camera or vis faces
	1086	camera->_notifyRenderedFaces(mDestRenderSystem->_getFaceCount());
	1087
	1088
	1089
	1090	}
	1091
	1092
	1093	//-----------------------------------------------------------------------
	1094	void SceneManager::_setDestinationRenderSystem(RenderSystem* sys)
	1095	{
	1096	mDestRenderSystem = sys;
	1097
	1098	}
	1099
	1100
	1101	//-----------------------------------------------------------------------
	1102	void SceneManager::setWorldGeometry(const String& filename)
	1103	{
	1104	// This default implementation cannot handle world geometry
	1105	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1106	"World geometry is not supported by the generic SceneManager.",
	1107	"SceneManager::setWorldGeometry");
	1108	}
	1109	//-----------------------------------------------------------------------
	1110	void SceneManager::setWorldGeometry(DataStreamPtr& stream,
	1111	const String& typeName)
	1112	{
	1113	// This default implementation cannot handle world geometry
	1114	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1115	"World geometry is not supported by the generic SceneManager.",
	1116	"SceneManager::setWorldGeometry");
	1117	}
	1118
	1119	//-----------------------------------------------------------------------
	1120	bool SceneManager::materialLess::operator() (const Material* x, const Material* y) const
	1121	{
	1122	// If x transparent and y not, x > y (since x has to overlap y)
	1123	if (x->isTransparent() && !y->isTransparent())
	1124	{
	1125	return false;
	1126	}
	1127	// If y is transparent and x not, x < y
	1128	else if (!x->isTransparent() && y->isTransparent())
	1129	{
	1130	return true;
	1131	}
	1132	else
	1133	{
	1134	// Otherwise don't care (both transparent or both solid)
	1135	// Just arbitrarily use pointer
	1136	return x < y;
	1137	}
	1138
	1139	}
	1140
	1141	//-----------------------------------------------------------------------
	1142	void SceneManager::setSkyPlane(
	1143	bool enable,
	1144	const Plane& plane,
	1145	const String& materialName,
	1146	Real gscale,
	1147	Real tiling,
	1148	bool drawFirst,
	1149	Real bow,
	1150	int xsegments, int ysegments,
	1151	const String& groupName)
	1152	{
	1153	if (enable)
	1154	{
	1155	String meshName = mName + "SkyPlane";
	1156	mSkyPlane = plane;
	1157
	1158	MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
	1159	if (m.isNull())
	1160	{
	1161	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1162	"Sky plane material '" + materialName + "' not found.",
	1163	"SceneManager::setSkyPlane");
	1164	}
	1165	// Make sure the material doesn't update the depth buffer
	1166	m->setDepthWriteEnabled(false);
	1167	// Ensure loaded
	1168	m->load();
	1169
	1170	mSkyPlaneDrawFirst = drawFirst;
	1171
	1172	// Set up the plane
	1173	MeshPtr planeMesh = MeshManager::getSingleton().getByName(meshName);
	1174	if (!planeMesh.isNull())
	1175	{
	1176	// Destroy the old one
	1177	MeshManager::getSingleton().remove(planeMesh->getHandle());
	1178	}
	1179
	1180	// Create up vector
	1181	Vector3 up = plane.normal.crossProduct(Vector3::UNIT_X);
	1182	if (up == Vector3::ZERO)
	1183	up = plane.normal.crossProduct(-Vector3::UNIT_Z);
	1184
	1185	// Create skyplane
	1186	if( bow > 0 )
	1187	{
	1188	// Build a curved skyplane
	1189	planeMesh = MeshManager::getSingleton().createCurvedPlane(
	1190	meshName, groupName, plane, gscale * 100, gscale * 100, gscale * bow * 100,
	1191	xsegments, ysegments, false, 1, tiling, tiling, up);
	1192	}
	1193	else
	1194	{
	1195	planeMesh = MeshManager::getSingleton().createPlane(
	1196	meshName, groupName, plane, gscale * 100, gscale * 100, xsegments, ysegments, false,
	1197	1, tiling, tiling, up);
	1198	}
	1199
	1200	// Create entity
	1201	if (mSkyPlaneEntity)
	1202	{
	1203	// destroy old one, do it by name for speed
	1204	destroyEntity(meshName);
	1205	}
	1206	// Create, use the same name for mesh and entity
	1207	mSkyPlaneEntity = createEntity(meshName, meshName);
	1208	mSkyPlaneEntity->setMaterialName(materialName);
	1209	mSkyPlaneEntity->setCastShadows(false);
	1210
	1211	// Create node and attach
	1212	if (!mSkyPlaneNode)
	1213	{
	1214	mSkyPlaneNode = createSceneNode(meshName + "Node");
	1215	}
	1216	else
	1217	{
	1218	mSkyPlaneNode->detachAllObjects();
	1219	}
	1220	mSkyPlaneNode->attachObject(mSkyPlaneEntity);
	1221
	1222	}
	1223	mSkyPlaneEnabled = enable;
	1224	mSkyPlaneGenParameters.skyPlaneBow = bow;
	1225	mSkyPlaneGenParameters.skyPlaneScale = gscale;
	1226	mSkyPlaneGenParameters.skyPlaneTiling = tiling;
	1227	mSkyPlaneGenParameters.skyPlaneXSegments = xsegments;
	1228	mSkyPlaneGenParameters.skyPlaneYSegments = ysegments;
	1229	}
	1230	//-----------------------------------------------------------------------
	1231	void SceneManager::setSkyBox(
	1232	bool enable,
	1233	const String& materialName,
	1234	Real distance,
	1235	bool drawFirst,
	1236	const Quaternion& orientation,
	1237	const String& groupName)
	1238	{
	1239	if (enable)
	1240	{
	1241	MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
	1242	if (m.isNull())
	1243	{
	1244	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1245	"Sky box material '" + materialName + "' not found.",
	1246	"SceneManager::setSkyBox");
	1247	}
	1248	// Make sure the material doesn't update the depth buffer
	1249	m->setDepthWriteEnabled(false);
	1250	// Ensure loaded
	1251	m->load();
	1252	// Also clamp texture, don't wrap (otherwise edges can get filtered)
	1253	m->getBestTechnique()->getPass(0)->getTextureUnitState(0)->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
	1254
	1255
	1256	mSkyBoxDrawFirst = drawFirst;
	1257
	1258	// Create node
	1259	if (!mSkyBoxNode)
	1260	{
	1261	mSkyBoxNode = createSceneNode("SkyBoxNode");
	1262	}
	1263	else
	1264	{
	1265	mSkyBoxNode->detachAllObjects();
	1266	}
	1267
	1268	MaterialManager& matMgr = MaterialManager::getSingleton();
	1269	// Set up the box (6 planes)
	1270	for (int i = 0; i < 6; ++i)
	1271	{
	1272	MeshPtr planeMesh = createSkyboxPlane((BoxPlane)i, distance, orientation, groupName);
	1273	String entName = mName + "SkyBoxPlane" + StringConverter::toString(i);
	1274
	1275	// Create entity
	1276	if (mSkyBoxEntity[i])
	1277	{
	1278	// destroy old one, do it by name for speed
	1279	destroyEntity(entName);
	1280	}
	1281	mSkyBoxEntity[i] = createEntity(entName, planeMesh->getName());
	1282	mSkyBoxEntity[i]->setCastShadows(false);
	1283	// Have to create 6 materials, one for each frame
	1284	// Used to use combined material but now we're using queue we can't split to change frame
	1285	// This doesn't use much memory because textures aren't duplicated
	1286	MaterialPtr boxMat = matMgr.getByName(entName);
	1287	if (boxMat.isNull())
	1288	{
	1289	// Create new by clone
	1290	boxMat = m->clone(entName);
	1291	boxMat->load();
	1292	}
	1293	else
	1294	{
	1295	// Copy over existing
	1296	m->copyDetailsTo(boxMat);
	1297	boxMat->load();
	1298	}
	1299	// Set active frame
	1300	boxMat->getBestTechnique()->getPass(0)->getTextureUnitState(0)
	1301	->setCurrentFrame(i);
	1302
	1303	mSkyBoxEntity[i]->setMaterialName(boxMat->getName());
	1304
	1305	// Attach to node
	1306	mSkyBoxNode->attachObject(mSkyBoxEntity[i]);
	1307	} // for each plane
	1308
	1309	}
	1310	mSkyBoxEnabled = enable;
	1311	mSkyBoxGenParameters.skyBoxDistance = distance;
	1312	}
	1313	//-----------------------------------------------------------------------
	1314	void SceneManager::setSkyDome(
	1315	bool enable,
	1316	const String& materialName,
	1317	Real curvature,
	1318	Real tiling,
	1319	Real distance,
	1320	bool drawFirst,
	1321	const Quaternion& orientation,
	1322	int xsegments, int ysegments, int ySegmentsToKeep,
	1323	const String& groupName)
	1324	{
	1325	if (enable)
	1326	{
	1327	MaterialPtr m = MaterialManager::getSingleton().getByName(materialName);
	1328	if (m.isNull())
	1329	{
	1330	OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
	1331	"Sky dome material '" + materialName + "' not found.",
	1332	"SceneManager::setSkyDome");
	1333	}
	1334	// Make sure the material doesn't update the depth buffer
	1335	m->setDepthWriteEnabled(false);
	1336	// Ensure loaded
	1337	m->load();
	1338
	1339	mSkyDomeDrawFirst = drawFirst;
	1340
	1341	// Create node
	1342	if (!mSkyDomeNode)
	1343	{
	1344	mSkyDomeNode = createSceneNode("SkyDomeNode");
	1345	}
	1346	else
	1347	{
	1348	mSkyDomeNode->detachAllObjects();
	1349	}
	1350
	1351	// Set up the dome (5 planes)
	1352	for (int i = 0; i < 5; ++i)
	1353	{
	1354	MeshPtr planeMesh = createSkydomePlane((BoxPlane)i, curvature,
	1355	tiling, distance, orientation, xsegments, ysegments,
	1356	i!=BP_UP ? ySegmentsToKeep : -1, groupName);
	1357
	1358	String entName = "SkyDomePlane" + StringConverter::toString(i);
	1359
	1360	// Create entity
	1361	if (mSkyDomeEntity[i])
	1362	{
	1363	// destroy old one, do it by name for speed
	1364	destroyEntity(entName);
	1365	}
	1366	mSkyDomeEntity[i] = createEntity(entName, planeMesh->getName());
	1367	mSkyDomeEntity[i]->setMaterialName(m->getName());
	1368	mSkyDomeEntity[i]->setCastShadows(false);
	1369
	1370	// Attach to node
	1371	mSkyDomeNode->attachObject(mSkyDomeEntity[i]);
	1372	} // for each plane
	1373
	1374	}
	1375	mSkyDomeEnabled = enable;
	1376	mSkyDomeGenParameters.skyDomeCurvature = curvature;
	1377	mSkyDomeGenParameters.skyDomeDistance = distance;
	1378	mSkyDomeGenParameters.skyDomeTiling = tiling;
	1379	mSkyDomeGenParameters.skyDomeXSegments = xsegments;
	1380	mSkyDomeGenParameters.skyDomeYSegments = ysegments;
	1381	mSkyDomeGenParameters.skyDomeYSegments_keep = ySegmentsToKeep;
	1382	}
	1383	//-----------------------------------------------------------------------
	1384	MeshPtr SceneManager::createSkyboxPlane(
	1385	BoxPlane bp,
	1386	Real distance,
	1387	const Quaternion& orientation,
	1388	const String& groupName)
	1389	{
	1390	Plane plane;
	1391	String meshName;
	1392	Vector3 up;
	1393
	1394	meshName = mName + "SkyBoxPlane_";
	1395	// Set up plane equation
	1396	plane.d = distance;
	1397	switch(bp)
	1398	{
	1399	case BP_FRONT:
	1400	plane.normal = Vector3::UNIT_Z;
	1401	up = Vector3::UNIT_Y;
	1402	meshName += "Front";
	1403	break;
	1404	case BP_BACK:
	1405	plane.normal = -Vector3::UNIT_Z;
	1406	up = Vector3::UNIT_Y;
	1407	meshName += "Back";
	1408	break;
	1409	case BP_LEFT:
	1410	plane.normal = Vector3::UNIT_X;
	1411	up = Vector3::UNIT_Y;
	1412	meshName += "Left";
	1413	break;
	1414	case BP_RIGHT:
	1415	plane.normal = -Vector3::UNIT_X;
	1416	up = Vector3::UNIT_Y;
	1417	meshName += "Right";
	1418	break;
	1419	case BP_UP:
	1420	plane.normal = -Vector3::UNIT_Y;
	1421	up = Vector3::UNIT_Z;
	1422	meshName += "Up";
	1423	break;
	1424	case BP_DOWN:
	1425	plane.normal = Vector3::UNIT_Y;
	1426	up = -Vector3::UNIT_Z;
	1427	meshName += "Down";
	1428	break;
	1429	}
	1430	// Modify by orientation
	1431	plane.normal = orientation * plane.normal;
	1432	up = orientation * up;
	1433
	1434
	1435	// Check to see if existing plane
	1436	MeshManager& mm = MeshManager::getSingleton();
	1437	MeshPtr planeMesh = mm.getByName(meshName);
	1438	if(!planeMesh.isNull())
	1439	{
	1440	// destroy existing
	1441	mm.remove(planeMesh->getHandle());
	1442	}
	1443	// Create new
	1444	Real planeSize = distance * 2;
	1445	const int BOX_SEGMENTS = 1;
	1446	planeMesh = mm.createPlane(meshName, groupName, plane, planeSize, planeSize,
	1447	BOX_SEGMENTS, BOX_SEGMENTS, false, 1, 1, 1, up);
	1448
	1449	//planeMesh->_dumpContents(meshName);
	1450
	1451	return planeMesh;
	1452
	1453	}
	1454	//-----------------------------------------------------------------------
	1455	MeshPtr SceneManager::createSkydomePlane(
	1456	BoxPlane bp,
	1457	Real curvature,
	1458	Real tiling,
	1459	Real distance,
	1460	const Quaternion& orientation,
	1461	int xsegments, int ysegments, int ysegments_keep,
	1462	const String& groupName)
	1463	{
	1464
	1465	Plane plane;
	1466	String meshName;
	1467	Vector3 up;
	1468
	1469	meshName = mName + "SkyDomePlane_";
	1470	// Set up plane equation
	1471	plane.d = distance;
	1472	switch(bp)
	1473	{
	1474	case BP_FRONT:
	1475	plane.normal = Vector3::UNIT_Z;
	1476	up = Vector3::UNIT_Y;
	1477	meshName += "Front";
	1478	break;
	1479	case BP_BACK:
	1480	plane.normal = -Vector3::UNIT_Z;
	1481	up = Vector3::UNIT_Y;
	1482	meshName += "Back";
	1483	break;
	1484	case BP_LEFT:
	1485	plane.normal = Vector3::UNIT_X;
	1486	up = Vector3::UNIT_Y;
	1487	meshName += "Left";
	1488	break;
	1489	case BP_RIGHT:
	1490	plane.normal = -Vector3::UNIT_X;
	1491	up = Vector3::UNIT_Y;
	1492	meshName += "Right";
	1493	break;
	1494	case BP_UP:
	1495	plane.normal = -Vector3::UNIT_Y;
	1496	up = Vector3::UNIT_Z;
	1497	meshName += "Up";
	1498	break;
	1499	case BP_DOWN:
	1500	// no down
	1501	return MeshPtr();
	1502	}
	1503	// Modify by orientation
	1504	plane.normal = orientation * plane.normal;
	1505	up = orientation * up;
	1506
	1507	// Check to see if existing plane
	1508	MeshManager& mm = MeshManager::getSingleton();
	1509	MeshPtr planeMesh = mm.getByName(meshName);
	1510	if(!planeMesh.isNull())
	1511	{
	1512	// destroy existing
	1513	mm.remove(planeMesh->getHandle());
	1514	}
	1515	// Create new
	1516	Real planeSize = distance * 2;
	1517	planeMesh = mm.createCurvedIllusionPlane(meshName, groupName, plane,
	1518	planeSize, planeSize, curvature,
	1519	xsegments, ysegments, false, 1, tiling, tiling, up,
	1520	orientation, HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY, HardwareBuffer::HBU_STATIC_WRITE_ONLY,
	1521	false, false, ysegments_keep);
	1522
	1523	//planeMesh->_dumpContents(meshName);
	1524
	1525	return planeMesh;
	1526
	1527	}
	1528
	1529
	1530	//-----------------------------------------------------------------------
	1531	void SceneManager::_updateSceneGraph(Camera* cam)
	1532	{
	1533	// Process queued needUpdate calls
	1534	Node::processQueuedUpdates();
	1535
	1536	// Cascade down the graph updating transforms & world bounds
	1537	// In this implementation, just update from the root
	1538	// Smarter SceneManager subclasses may choose to update only
	1539	// certain scene graph branches
	1540	mSceneRoot->_update(true, false);
	1541
	1542
	1543	}
	1544	//-----------------------------------------------------------------------
	1545	void SceneManager::_findVisibleObjects(Camera* cam, bool onlyShadowCasters)
	1546	{
	1547	// Tell nodes to find, cascade down all nodes
	1548	mSceneRoot->_findVisibleObjects(cam, getRenderQueue(), true,
	1549	mDisplayNodes, onlyShadowCasters);
	1550
	1551	}
	1552	//-----------------------------------------------------------------------
	1553	void SceneManager::_renderVisibleObjects(void)
	1554	{
	1555	RenderQueueInvocationSequence* invocationSequence =
	1556	mCurrentViewport->_getRenderQueueInvocationSequence();
	1557	// Use custom sequence only if we're not doing the texture shadow render
	1558	// since texture shadow render should not be interfered with by suppressing
	1559	// render state changes for example
	1560	if (invocationSequence && mIlluminationStage != IRS_RENDER_TO_TEXTURE)
	1561	{
	1562	renderVisibleObjectsCustomSequence(invocationSequence);
	1563	}
	1564	else
	1565	{
	1566	renderVisibleObjectsDefaultSequence();
	1567	}
	1568	}
	1569	//-----------------------------------------------------------------------
	1570	void SceneManager::renderVisibleObjectsCustomSequence(RenderQueueInvocationSequence* seq)
	1571	{
	1572	RenderQueueInvocationIterator invocationIt = seq->iterator();
	1573	while (invocationIt.hasMoreElements())
	1574	{
	1575	RenderQueueInvocation* invocation = invocationIt.getNext();
	1576	uint8 qId = invocation->getRenderQueueGroupID();
	1577	// Skip this one if not to be processed
	1578	if (!isRenderQueueToBeProcessed(qId))
	1579	continue;
	1580
	1581
	1582	bool repeatQueue = false;
	1583	const String& invocationName = invocation->getInvocationName();
	1584	RenderQueueGroup* queueGroup = getRenderQueue()->getQueueGroup(qId);
	1585	do // for repeating queues
	1586	{
	1587	// Fire queue started event
	1588	if (fireRenderQueueStarted(qId, invocationName))
	1589	{
	1590	// Someone requested we skip this queue
	1591	break;
	1592	}
	1593
	1594	// Invoke it
	1595	invocation->invoke(queueGroup, this);
	1596
	1597	// Fire queue ended event
	1598	if (fireRenderQueueEnded(qId, invocationName))
	1599	{
	1600	// Someone requested we repeat this queue
	1601	repeatQueue = true;
	1602	}
	1603	else
	1604	{
	1605	repeatQueue = false;
	1606	}
	1607	} while (repeatQueue);
	1608
	1609
	1610	}
	1611	}
	1612	//-----------------------------------------------------------------------
	1613	void SceneManager::renderVisibleObjectsDefaultSequence(void)
	1614	{
	1615	// Render each separate queue
	1616	RenderQueue::QueueGroupIterator queueIt = getRenderQueue()->_getQueueGroupIterator();
	1617
	1618	// NB only queues which have been created are rendered, no time is wasted
	1619	// parsing through non-existent queues (even though there are 10 available)
	1620
	1621	while (queueIt.hasMoreElements())
	1622	{
	1623	// Get queue group id
	1624	uint8 qId = queueIt.peekNextKey();
	1625	RenderQueueGroup* pGroup = queueIt.getNext();
	1626	// Skip this one if not to be processed
	1627	if (!isRenderQueueToBeProcessed(qId))
	1628	continue;
	1629
	1630
	1631	bool repeatQueue = false;
	1632	do // for repeating queues
	1633	{
	1634	// Fire queue started event
	1635	if (fireRenderQueueStarted(qId,
	1636	mIlluminationStage == IRS_RENDER_TO_TEXTURE ?
	1637	RenderQueueInvocation::RENDER_QUEUE_INVOCATION_SHADOWS :
	1638	StringUtil::BLANK))
	1639	{
	1640	// Someone requested we skip this queue
	1641	break;
	1642	}
	1643
	1644	_renderQueueGroupObjects(pGroup, QueuedRenderableCollection::OM_PASS_GROUP);
	1645
	1646	// Fire queue ended event
	1647	if (fireRenderQueueEnded(qId,
	1648	mIlluminationStage == IRS_RENDER_TO_TEXTURE ?
	1649	RenderQueueInvocation::RENDER_QUEUE_INVOCATION_SHADOWS :
	1650	StringUtil::BLANK))
	1651	{
	1652	// Someone requested we repeat this queue
	1653	repeatQueue = true;
	1654	}
	1655	else
	1656	{
	1657	repeatQueue = false;
	1658	}
	1659	} while (repeatQueue);
	1660
	1661	} // for each queue group
	1662
	1663	}
	1664	//-----------------------------------------------------------------------
	1665	void SceneManager::renderAdditiveStencilShadowedQueueGroupObjects(
	1666	RenderQueueGroup* pGroup,
	1667	QueuedRenderableCollection::OrganisationMode om)
	1668	{
	1669	RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
	1670	LightList lightList;
	1671
	1672	while (groupIt.hasMoreElements())
	1673	{
	1674	RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
	1675
	1676	// Sort the queue first
	1677	pPriorityGrp->sort(mCameraInProgress);
	1678
	1679	// Clear light list
	1680	lightList.clear();
	1681
	1682	// Render all the ambient passes first, no light iteration, no lights
	1683	renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &lightList);
	1684	// Also render any objects which have receive shadows disabled
	1685	renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);
	1686
	1687
	1688	// Now iterate per light
	1689	// Iterate over lights, render all volumes to stencil
	1690	LightList::const_iterator li, liend;
	1691	liend = mLightsAffectingFrustum.end();
	1692
	1693	for (li = mLightsAffectingFrustum.begin(); li != liend; ++li)
	1694	{
	1695	Light* l = *li;
	1696	// Set light state
	1697
	1698	if (l->getCastShadows())
	1699	{
	1700	// Clear stencil
	1701	mDestRenderSystem->clearFrameBuffer(FBT_STENCIL);
	1702	renderShadowVolumesToStencil(l, mCameraInProgress);
	1703	// turn stencil check on
	1704	mDestRenderSystem->setStencilCheckEnabled(true);
	1705	// NB we render where the stencil is equal to zero to render lit areas
	1706	mDestRenderSystem->setStencilBufferParams(CMPF_EQUAL, 0);
	1707	}
	1708
	1709	// render lighting passes for this light
	1710	if (lightList.empty())
	1711	lightList.push_back(l);
	1712	else
	1713	lightList[0] = l;
	1714	renderObjects(pPriorityGrp->getSolidsDiffuseSpecular(), om, false, &lightList);
	1715
	1716	// Reset stencil params
	1717	mDestRenderSystem->setStencilBufferParams();
	1718	mDestRenderSystem->setStencilCheckEnabled(false);
	1719	mDestRenderSystem->_setDepthBufferParams();
	1720
	1721	}// for each light
	1722
	1723
	1724	// Now render decal passes, no need to set lights as lighting will be disabled
	1725	renderObjects(pPriorityGrp->getSolidsDecal(), om, false);
	1726
	1727
	1728	}// for each priority
	1729
	1730	// Iterate again - variable name changed to appease gcc.
	1731	RenderQueueGroup::PriorityMapIterator groupIt2 = pGroup->getIterator();
	1732	while (groupIt2.hasMoreElements())
	1733	{
	1734	RenderPriorityGroup* pPriorityGrp = groupIt2.getNext();
	1735
	1736	// Do transparents (always descending sort)
	1737	renderObjects(pPriorityGrp->getTransparents(),
	1738	QueuedRenderableCollection::OM_SORT_DESCENDING, true);
	1739
	1740	}// for each priority
	1741
	1742
	1743	}
	1744	//-----------------------------------------------------------------------
	1745	void SceneManager::renderModulativeStencilShadowedQueueGroupObjects(
	1746	RenderQueueGroup* pGroup,
	1747	QueuedRenderableCollection::OrganisationMode om)
	1748	{
	1749	/* For each light, we need to render all the solids from each group,
	1750	then do the modulative shadows, then render the transparents from
	1751	each group.
	1752	Now, this means we are going to reorder things more, but that it required
	1753	if the shadows are to look correct. The overall order is preserved anyway,
	1754	it's just that all the transparents are at the end instead of them being
	1755	interleaved as in the normal rendering loop.
	1756	*/
	1757	// Iterate through priorities
	1758	RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
	1759
	1760	while (groupIt.hasMoreElements())
	1761	{
	1762	RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
	1763
	1764	// Sort the queue first
	1765	pPriorityGrp->sort(mCameraInProgress);
	1766
	1767	// Do (shadowable) solids
	1768	renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
	1769	}
	1770
	1771
	1772	// Iterate over lights, render all volumes to stencil
	1773	LightList::const_iterator li, liend;
	1774	liend = mLightsAffectingFrustum.end();
	1775
	1776	for (li = mLightsAffectingFrustum.begin(); li != liend; ++li)
	1777	{
	1778	Light* l = *li;
	1779	if (l->getCastShadows())
	1780	{
	1781	// Clear stencil
	1782	mDestRenderSystem->clearFrameBuffer(FBT_STENCIL);
	1783	renderShadowVolumesToStencil(l, mCameraInProgress);
	1784	// render full-screen shadow modulator for all lights
	1785	_setPass(mShadowModulativePass);
	1786	// turn stencil check on
	1787	mDestRenderSystem->setStencilCheckEnabled(true);
	1788	// NB we render where the stencil is not equal to zero to render shadows, not lit areas
	1789	mDestRenderSystem->setStencilBufferParams(CMPF_NOT_EQUAL, 0);
	1790	renderSingleObject(mFullScreenQuad, mShadowModulativePass, false);
	1791	// Reset stencil params
	1792	mDestRenderSystem->setStencilBufferParams();
	1793	mDestRenderSystem->setStencilCheckEnabled(false);
	1794	mDestRenderSystem->_setDepthBufferParams();
	1795	}
	1796
	1797	}// for each light
	1798
	1799	// Iterate again - variable name changed to appease gcc.
	1800	RenderQueueGroup::PriorityMapIterator groupIt2 = pGroup->getIterator();
	1801	while (groupIt2.hasMoreElements())
	1802	{
	1803	RenderPriorityGroup* pPriorityGrp = groupIt2.getNext();
	1804
	1805	// Do non-shadowable solids
	1806	renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);
	1807
	1808	}// for each priority
	1809
	1810
	1811	// Iterate again - variable name changed to appease gcc.
	1812	RenderQueueGroup::PriorityMapIterator groupIt3 = pGroup->getIterator();
	1813	while (groupIt3.hasMoreElements())
	1814	{
	1815	RenderPriorityGroup* pPriorityGrp = groupIt3.getNext();
	1816
	1817	// Do transparents (always descending sort)
	1818	renderObjects(pPriorityGrp->getTransparents(),
	1819	QueuedRenderableCollection::OM_SORT_DESCENDING, true);
	1820
	1821	}// for each priority
	1822
	1823	}
	1824	//-----------------------------------------------------------------------
	1825	void SceneManager::renderTextureShadowCasterQueueGroupObjects(
	1826	RenderQueueGroup* pGroup,
	1827	QueuedRenderableCollection::OrganisationMode om)
	1828	{
	1829	static LightList nullLightList;
	1830	// This is like the basic group render, except we skip all transparents
	1831	// and we also render any non-shadowed objects
	1832	// Note that non-shadow casters will have already been eliminated during
	1833	// _findVisibleObjects
	1834
	1835	// Iterate through priorities
	1836	RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
	1837
	1838	// Override auto param ambient to force vertex programs and fixed function to
	1839	if (isShadowTechniqueAdditive())
	1840	{
	1841	// Use simple black / white mask if additive
	1842	mAutoParamDataSource.setAmbientLightColour(ColourValue::Black);
	1843	mDestRenderSystem->setAmbientLight(0, 0, 0);
	1844	}
	1845	else
	1846	{
	1847	// Use shadow colour as caster colour if modulative
	1848	mAutoParamDataSource.setAmbientLightColour(mShadowColour);
	1849	mDestRenderSystem->setAmbientLight(mShadowColour.r, mShadowColour.g, mShadowColour.b);
	1850	}
	1851
	1852	while (groupIt.hasMoreElements())
	1853	{
	1854	RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
	1855
	1856	// Sort the queue first
	1857	pPriorityGrp->sort(mCameraInProgress);
	1858
	1859	// Do solids, override light list incase any vertex programs use them
	1860	renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &nullLightList);
	1861	renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, false, &nullLightList);
	1862	// Do transparents that cast shadows
	1863	renderTransparentShadowCasterObjects(
	1864	pPriorityGrp->getTransparents(),
	1865	QueuedRenderableCollection::OM_SORT_DESCENDING,
	1866	false, &nullLightList);
	1867
	1868
	1869	}// for each priority
	1870
	1871	// reset ambient light
	1872	mAutoParamDataSource.setAmbientLightColour(mAmbientLight);
	1873	mDestRenderSystem->setAmbientLight(mAmbientLight.r, mAmbientLight.g, mAmbientLight.b);
	1874	}
	1875	//-----------------------------------------------------------------------
	1876	void SceneManager::renderModulativeTextureShadowedQueueGroupObjects(
	1877	RenderQueueGroup* pGroup,
	1878	QueuedRenderableCollection::OrganisationMode om)
	1879	{
	1880	/* For each light, we need to render all the solids from each group,
	1881	then do the modulative shadows, then render the transparents from
	1882	each group.
	1883	Now, this means we are going to reorder things more, but that it required
	1884	if the shadows are to look correct. The overall order is preserved anyway,
	1885	it's just that all the transparents are at the end instead of them being
	1886	interleaved as in the normal rendering loop.
	1887	*/
	1888	// Iterate through priorities
	1889	RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
	1890
	1891	while (groupIt.hasMoreElements())
	1892	{
	1893	RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
	1894
	1895	// Sort the queue first
	1896	pPriorityGrp->sort(mCameraInProgress);
	1897
	1898	// Do solids
	1899	renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
	1900	renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);
	1901	}
	1902
	1903
	1904	// Iterate over lights, render received shadows
	1905	// only perform this if we're in the 'normal' render stage, to avoid
	1906	// doing it during the render to texture
	1907	if (mIlluminationStage == IRS_NONE)
	1908	{
	1909	mIlluminationStage = IRS_RENDER_RECEIVER_PASS;
	1910
	1911	LightList::iterator i, iend;
	1912	ShadowTextureList::iterator si, siend;
	1913	iend = mLightsAffectingFrustum.end();
	1914	siend = mShadowTextures.end();
	1915	for (i = mLightsAffectingFrustum.begin(), si = mShadowTextures.begin();
	1916	i != iend && si != siend; ++i)
	1917	{
	1918	Light* l = *i;
	1919
	1920	if (!l->getCastShadows())
	1921	continue;
	1922
	1923	// Store current shadow texture
	1924	mCurrentShadowTexture = si->getPointer();
	1925	// Get camera for current shadow texture
	1926	Camera *cam = mCurrentShadowTexture->getBuffer()->getRenderTarget()->getViewport(0)->getCamera();
	1927	// Hook up receiver texture
	1928	Pass* targetPass = mShadowTextureCustomReceiverPass ?
	1929	mShadowTextureCustomReceiverPass : mShadowReceiverPass;
	1930	targetPass->getTextureUnitState(0)->setTextureName(
	1931	mCurrentShadowTexture->getName());
	1932	// Hook up projection frustum
	1933	targetPass->getTextureUnitState(0)->setProjectiveTexturing(true, cam);
	1934	mAutoParamDataSource.setTextureProjector(cam);
	1935	// if this light is a spotlight, we need to add the spot fader layer
	1936	if (l->getType() == Light::LT_SPOTLIGHT)
	1937	{
	1938	// remove all TUs except 0 & 1
	1939	// (only an issue if additive shadows have been used)
	1940	while(targetPass->getNumTextureUnitStates() > 2)
	1941	targetPass->removeTextureUnitState(2);
	1942
	1943	// Add spot fader if not present already
	1944	if (targetPass->getNumTextureUnitStates() == 2 &&
	1945	targetPass->getTextureUnitState(1)->getTextureName() ==
	1946	"spot_shadow_fade.png")
	1947	{
	1948	// Just set
	1949	TextureUnitState* t =
	1950	targetPass->getTextureUnitState(1);
	1951	t->setProjectiveTexturing(true, cam);
	1952	}
	1953	else
	1954	{
	1955	// Remove any non-conforming spot layers
	1956	while(targetPass->getNumTextureUnitStates() > 1)
	1957	targetPass->removeTextureUnitState(1);
	1958
	1959	TextureUnitState* t =
	1960	mShadowReceiverPass->createTextureUnitState("spot_shadow_fade.png");
	1961	t->setProjectiveTexturing(true, cam);
	1962	t->setColourOperation(LBO_ADD);
	1963	t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
	1964	}
	1965	}
	1966	else
	1967	{
	1968	// remove all TUs except 0 including spot
	1969	while(targetPass->getNumTextureUnitStates() > 1)
	1970	targetPass->removeTextureUnitState(1);
	1971
	1972	}
	1973	// Set lighting / blending modes
	1974	targetPass->setSceneBlending(SBF_DEST_COLOUR, SBF_ZERO);
	1975	targetPass->setLightingEnabled(false);
	1976
	1977	targetPass->_load();
	1978
	1979	// Fire pre-receiver event
	1980	fireShadowTexturesPreReceiver(l, cam);
	1981
	1982	renderTextureShadowReceiverQueueGroupObjects(pGroup, om);
	1983
	1984	++si;
	1985
	1986	}// for each light
	1987
	1988	mIlluminationStage = IRS_NONE;
	1989
	1990	}
	1991
	1992	// Iterate again - variable name changed to appease gcc.
	1993	RenderQueueGroup::PriorityMapIterator groupIt3 = pGroup->getIterator();
	1994	while (groupIt3.hasMoreElements())
	1995	{
	1996	RenderPriorityGroup* pPriorityGrp = groupIt3.getNext();
	1997
	1998	// Do transparents (always descending)
	1999	renderObjects(pPriorityGrp->getTransparents(),
	2000	QueuedRenderableCollection::OM_SORT_DESCENDING, true);
	2001
	2002	}// for each priority
	2003
	2004	}
	2005	//-----------------------------------------------------------------------
	2006	void SceneManager::renderAdditiveTextureShadowedQueueGroupObjects(
	2007	RenderQueueGroup* pGroup,
	2008	QueuedRenderableCollection::OrganisationMode om)
	2009	{
	2010	RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
	2011	LightList lightList;
	2012
	2013	while (groupIt.hasMoreElements())
	2014	{
	2015	RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
	2016
	2017	// Sort the queue first
	2018	pPriorityGrp->sort(mCameraInProgress);
	2019
	2020	// Clear light list
	2021	lightList.clear();
	2022
	2023	// Render all the ambient passes first, no light iteration, no lights
	2024	renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &lightList);
	2025	// Also render any objects which have receive shadows disabled
	2026	renderObjects(pPriorityGrp->getSolidsNoShadowReceive(), om, true);
	2027
	2028
	2029	// only perform this next part if we're in the 'normal' render stage, to avoid
	2030	// doing it during the render to texture
	2031	if (mIlluminationStage == IRS_NONE)
	2032	{
	2033	// Iterate over lights, render masked
	2034	LightList::const_iterator li, liend;
	2035	ShadowTextureList::iterator si, siend;
	2036	liend = mLightsAffectingFrustum.end();
	2037	siend = mShadowTextures.end();
	2038	si = mShadowTextures.begin();
	2039
	2040	for (li = mLightsAffectingFrustum.begin(); li != liend; ++li)
	2041	{
	2042	Light* l = *li;
	2043
	2044	if (l->getCastShadows() && si != siend)
	2045	{
	2046	// Store current shadow texture
	2047	mCurrentShadowTexture = si->getPointer();
	2048	// Get camera for current shadow texture
	2049	Camera *cam = mCurrentShadowTexture->getBuffer()->getRenderTarget()->getViewport(0)->getCamera();
	2050	// Hook up receiver texture
	2051	Pass* targetPass = mShadowTextureCustomReceiverPass ?
	2052	mShadowTextureCustomReceiverPass : mShadowReceiverPass;
	2053	targetPass->getTextureUnitState(0)->setTextureName(
	2054	mCurrentShadowTexture->getName());
	2055	// Hook up projection frustum
	2056	targetPass->getTextureUnitState(0)->setProjectiveTexturing(true, cam);
	2057	mAutoParamDataSource.setTextureProjector(cam);
	2058	// Remove any spot fader layer
	2059	if (targetPass->getNumTextureUnitStates() > 1 &&
	2060	targetPass->getTextureUnitState(1)->getTextureName()
	2061	== "spot_shadow_fade.png")
	2062	{
	2063	// remove spot fader layer (should only be there if
	2064	// we previously used modulative shadows)
	2065	targetPass->removeTextureUnitState(1);
	2066	}
	2067	// Set lighting / blending modes
	2068	targetPass->setSceneBlending(SBF_ONE, SBF_ONE);
	2069	targetPass->setLightingEnabled(true);
	2070	targetPass->_load();
	2071
	2072	// increment shadow texture since used
	2073	++si;
	2074
	2075	mIlluminationStage = IRS_RENDER_RECEIVER_PASS;
	2076
	2077	}
	2078	else
	2079	{
	2080	mIlluminationStage = IRS_NONE;
	2081
	2082	}
	2083
	2084	// render lighting passes for this light
	2085	if (lightList.empty())
	2086	lightList.push_back(l);
	2087	else
	2088	lightList[0] = l;
	2089	renderObjects(pPriorityGrp->getSolidsDiffuseSpecular(), om, false, &lightList);
	2090
	2091	}// for each light
	2092
	2093	mIlluminationStage = IRS_NONE;
	2094
	2095	// Now render decal passes, no need to set lights as lighting will be disabled
	2096	renderObjects(pPriorityGrp->getSolidsDecal(), om, false);
	2097
	2098	}
	2099
	2100
	2101	}// for each priority
	2102
	2103	// Iterate again - variable name changed to appease gcc.
	2104	RenderQueueGroup::PriorityMapIterator groupIt2 = pGroup->getIterator();
	2105	while (groupIt2.hasMoreElements())
	2106	{
	2107	RenderPriorityGroup* pPriorityGrp = groupIt2.getNext();
	2108
	2109	// Do transparents (always descending sort)
	2110	renderObjects(pPriorityGrp->getTransparents(),
	2111	QueuedRenderableCollection::OM_SORT_DESCENDING, true);
	2112
	2113	}// for each priority
	2114
	2115	}
	2116	//-----------------------------------------------------------------------
	2117	void SceneManager::renderTextureShadowReceiverQueueGroupObjects(
	2118	RenderQueueGroup* pGroup,
	2119	QueuedRenderableCollection::OrganisationMode om)
	2120	{
	2121	static LightList nullLightList;
	2122
	2123	// Iterate through priorities
	2124	RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
	2125
	2126	// Override auto param ambient to force vertex programs to go full-bright
	2127	mAutoParamDataSource.setAmbientLightColour(ColourValue::White);
	2128	mDestRenderSystem->setAmbientLight(1, 1, 1);
	2129
	2130	while (groupIt.hasMoreElements())
	2131	{
	2132	RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
	2133
	2134	// Do solids, override light list incase any vertex programs use them
	2135	renderObjects(pPriorityGrp->getSolidsBasic(), om, false, &nullLightList);
	2136
	2137	// Don't render transparents or passes which have shadow receipt disabled
	2138
	2139	}// for each priority
	2140
	2141	// reset ambient
	2142	mAutoParamDataSource.setAmbientLightColour(mAmbientLight);
	2143	mDestRenderSystem->setAmbientLight(mAmbientLight.r, mAmbientLight.g, mAmbientLight.b);
	2144
	2145	}
	2146	//-----------------------------------------------------------------------
	2147	void SceneManager::SceneMgrQueuedRenderableVisitor::visit(const Renderable* r)
	2148	{
	2149	// Give SM a chance to eliminate
	2150	if (targetSceneMgr->validateRenderableForRendering(mUsedPass, r))
	2151	{
	2152	// Render a single object, this will set up auto params if required
	2153	targetSceneMgr->renderSingleObject(r, mUsedPass, autoLights, manualLightList);
	2154	}
	2155	}
	2156	//-----------------------------------------------------------------------
	2157	bool SceneManager::SceneMgrQueuedRenderableVisitor::visit(const Pass* p)
	2158	{
	2159	// Give SM a chance to eliminate this pass
	2160	if (!targetSceneMgr->validatePassForRendering(p))
	2161	return false;
	2162
	2163	// Set pass, store the actual one used
	2164	mUsedPass = targetSceneMgr->_setPass(p);
	2165
	2166
	2167	return true;
	2168	}
	2169	//-----------------------------------------------------------------------
	2170	void SceneManager::SceneMgrQueuedRenderableVisitor::visit(const RenderablePass* rp)
	2171	{
	2172	// Skip this one if we're in transparency cast shadows mode & it doesn't
	2173	// Don't need to implement this one in the other visit methods since
	2174	// transparents are never grouped, always sorted
	2175	if (transparentShadowCastersMode &&
	2176	!rp->pass->getParent()->getParent()->getTransparencyCastsShadows())
	2177	return;
	2178
	2179	// Give SM a chance to eliminate
	2180	if (targetSceneMgr->validateRenderableForRendering(rp->pass, rp->renderable))
	2181	{
	2182	targetSceneMgr->_setPass(rp->pass);
	2183	targetSceneMgr->renderSingleObject(rp->renderable, rp->pass, autoLights,
	2184	manualLightList);
	2185	}
	2186	}
	2187	//-----------------------------------------------------------------------
	2188	bool SceneManager::validatePassForRendering(const Pass* pass)
	2189	{
	2190	// Bypass if we're doing a texture shadow render and
	2191	// this pass is after the first (only 1 pass needed for modulative shadow texture)
	2192	// Also bypass if passes above the first if render state changes are
	2193	// suppressed since we're not actually using this pass data anyway
	2194	if (!mSuppressShadows && mCurrentViewport->getShadowsEnabled() &&
	2195	isShadowTechniqueModulative() &&
	2196	(mIlluminationStage == IRS_RENDER_TO_TEXTURE \|\|
	2197	mIlluminationStage == IRS_RENDER_RECEIVER_PASS \|\|
	2198	mSuppressRenderStateChanges) &&
	2199	pass->getIndex() > 0)
	2200	{
	2201	return false;
	2202	}
	2203
	2204	return true;
	2205	}
	2206	//-----------------------------------------------------------------------
	2207	bool SceneManager::validateRenderableForRendering(const Pass* pass, const Renderable* rend)
	2208	{
	2209	// Skip this renderable if we're doing modulative texture shadows, it casts shadows
	2210	// and we're doing the render receivers pass and we're not self-shadowing
	2211	if (!mSuppressShadows && mCurrentViewport->getShadowsEnabled() &&
	2212	isShadowTechniqueTextureBased() &&
	2213	mIlluminationStage == IRS_RENDER_RECEIVER_PASS &&
	2214	rend->getCastsShadows() && !mShadowTextureSelfShadow &&
	2215	isShadowTechniqueModulative())
	2216	{
	2217	return false;
	2218	}
	2219
	2220	return true;
	2221
	2222	}
	2223	//-----------------------------------------------------------------------
	2224	void SceneManager::renderObjects(const QueuedRenderableCollection& objs,
	2225	QueuedRenderableCollection::OrganisationMode om,
	2226	bool doLightIteration,
	2227	const LightList* manualLightList)
	2228	{
	2229	mActiveQueuedRenderableVisitor->autoLights = doLightIteration;
	2230	mActiveQueuedRenderableVisitor->manualLightList = manualLightList;
	2231	mActiveQueuedRenderableVisitor->transparentShadowCastersMode = false;
	2232	// Use visitor
	2233	objs.acceptVisitor(mActiveQueuedRenderableVisitor, om);
	2234	}
	2235	//-----------------------------------------------------------------------
	2236	void SceneManager::_renderQueueGroupObjects(RenderQueueGroup* pGroup,
	2237	QueuedRenderableCollection::OrganisationMode om)
	2238	{
	2239	bool doShadows =
	2240	pGroup->getShadowsEnabled() &&
	2241	mCurrentViewport->getShadowsEnabled() &&
	2242	!mSuppressShadows && !mSuppressRenderStateChanges;
	2243
	2244	if (doShadows && mShadowTechnique == SHADOWTYPE_STENCIL_ADDITIVE)
	2245	{
	2246	// Additive stencil shadows in use
	2247	renderAdditiveStencilShadowedQueueGroupObjects(pGroup, om);
	2248	}
	2249	else if (doShadows && mShadowTechnique == SHADOWTYPE_STENCIL_MODULATIVE)
	2250	{
	2251	// Modulative stencil shadows in use
	2252	renderModulativeStencilShadowedQueueGroupObjects(pGroup, om);
	2253	}
	2254	else if (isShadowTechniqueTextureBased())
	2255	{
	2256	// Modulative texture shadows in use
	2257	if (mIlluminationStage == IRS_RENDER_TO_TEXTURE)
	2258	{
	2259	// Shadow caster pass
	2260	if (mCurrentViewport->getShadowsEnabled() &&
	2261	!mSuppressShadows && !mSuppressRenderStateChanges)
	2262	{
	2263	renderTextureShadowCasterQueueGroupObjects(pGroup, om);
	2264	}
	2265	}
	2266	else
	2267	{
	2268	// Ordinary + receiver pass
	2269	if (doShadows)
	2270	{
	2271	// Receiver pass(es)
	2272	if (isShadowTechniqueAdditive())
	2273	{
	2274	// Additive
	2275	renderAdditiveTextureShadowedQueueGroupObjects(pGroup, om);
	2276	}
	2277	else
	2278	{
	2279	// Modulative
	2280	renderModulativeTextureShadowedQueueGroupObjects(pGroup, om);
	2281	}
	2282	}
	2283	else
	2284	renderBasicQueueGroupObjects(pGroup, om);
	2285	}
	2286	}
	2287	else
	2288	{
	2289	// No shadows, ordinary pass
	2290	renderBasicQueueGroupObjects(pGroup, om);
	2291	}
	2292
	2293
	2294	}
	2295	//-----------------------------------------------------------------------
	2296	void SceneManager::renderBasicQueueGroupObjects(RenderQueueGroup* pGroup,
	2297	QueuedRenderableCollection::OrganisationMode om)
	2298	{
	2299	// Basic render loop
	2300	// Iterate through priorities
	2301	RenderQueueGroup::PriorityMapIterator groupIt = pGroup->getIterator();
	2302
	2303	while (groupIt.hasMoreElements())
	2304	{
	2305	RenderPriorityGroup* pPriorityGrp = groupIt.getNext();
	2306
	2307	// Sort the queue first
	2308	pPriorityGrp->sort(mCameraInProgress);
	2309
	2310	// Do solids
	2311	renderObjects(pPriorityGrp->getSolidsBasic(), om, true);
	2312	// Do transparents (always descending)
	2313	renderObjects(pPriorityGrp->getTransparents(),
	2314	QueuedRenderableCollection::OM_SORT_DESCENDING, true);
	2315
	2316
	2317	}// for each priority
	2318	}
	2319	//-----------------------------------------------------------------------
	2320	void SceneManager::renderTransparentShadowCasterObjects(
	2321	const QueuedRenderableCollection& objs,
	2322	QueuedRenderableCollection::OrganisationMode om, bool doLightIteration,
	2323	const LightList* manualLightList)
	2324	{
	2325	mActiveQueuedRenderableVisitor->transparentShadowCastersMode = true;
	2326	mActiveQueuedRenderableVisitor->autoLights = doLightIteration;
	2327	mActiveQueuedRenderableVisitor->manualLightList = manualLightList;
	2328
	2329	// Sort descending (transparency)
	2330	objs.acceptVisitor(mActiveQueuedRenderableVisitor,
	2331	QueuedRenderableCollection::OM_SORT_DESCENDING);
	2332
	2333	mActiveQueuedRenderableVisitor->transparentShadowCastersMode = false;
	2334	}
	2335	//-----------------------------------------------------------------------
	2336	void SceneManager::renderSingleObject(const Renderable* rend, const Pass* pass,
	2337	bool doLightIteration, const LightList* manualLightList)
	2338	{
	2339	unsigned short numMatrices;
	2340	static RenderOperation ro;
	2341	static LightList localLightList;
	2342
	2343	// Set up rendering operation
	2344	// I know, I know, const_cast is nasty but otherwise it requires all internal
	2345	// state of the Renderable assigned to the rop to be mutable
	2346	const_cast<Renderable*>(rend)->getRenderOperation(ro);
	2347	ro.srcRenderable = rend;
	2348
	2349	// Set world transformation
	2350	rend->getWorldTransforms(mTempXform);
	2351	numMatrices = rend->getNumWorldTransforms();
	2352	if (numMatrices > 1)
	2353	{
	2354	mDestRenderSystem->_setWorldMatrices(mTempXform, numMatrices);
	2355	}
	2356	else
	2357	{
	2358	mDestRenderSystem->_setWorldMatrix(*mTempXform);
	2359	}
	2360
	2361	// Issue view / projection changes if any
	2362	useRenderableViewProjMode(rend);
	2363
	2364	if (!mSuppressRenderStateChanges)
	2365	{
	2366	bool passSurfaceAndLightParams = true;
	2367
	2368	if (pass->isProgrammable())
	2369	{
	2370	// Tell auto params object about the renderable change
	2371	mAutoParamDataSource.setCurrentRenderable(rend);
	2372	pass->_updateAutoParamsNoLights(mAutoParamDataSource);
	2373	if (pass->hasVertexProgram())
	2374	{
	2375	passSurfaceAndLightParams = pass->getVertexProgram()->getPassSurfaceAndLightStates();
	2376	}
	2377	}
	2378
	2379	// Reissue any texture gen settings which are dependent on view matrix
	2380	Pass::ConstTextureUnitStateIterator texIter = pass->getTextureUnitStateIterator();
	2381	size_t unit = 0;
	2382	while(texIter.hasMoreElements())
	2383	{
	2384	TextureUnitState* pTex = texIter.getNext();
	2385	if (pTex->hasViewRelativeTextureCoordinateGeneration())
	2386	{
	2387	mDestRenderSystem->_setTextureUnitSettings(unit, *pTex);
	2388	}
	2389	++unit;
	2390	}
	2391
	2392	// Sort out normalisation
	2393	mDestRenderSystem->setNormaliseNormals(rend->getNormaliseNormals());
	2394
	2395	// Set up the solid / wireframe override
	2396	// Precedence is Camera, Object, Material
	2397	// Camera might not override object if not overrideable
	2398	PolygonMode reqMode = pass->getPolygonMode();
	2399	if (rend->getPolygonModeOverrideable())
	2400	{
	2401	PolygonMode camPolyMode = mCameraInProgress->getPolygonMode();
	2402	// check camera detial only when render detail is overridable
	2403	if (reqMode > camPolyMode)
	2404	{
	2405	// only downgrade detail; if cam says wireframe we don't go up to solid
	2406	reqMode = camPolyMode;
	2407	}
	2408	}
	2409	mDestRenderSystem->_setPolygonMode(reqMode);
	2410
	2411	mDestRenderSystem->setClipPlanes(rend->getClipPlanes());
	2412
	2413	if (doLightIteration)
	2414	{
	2415	// Here's where we issue the rendering operation to the render system
	2416	// Note that we may do this once per light, therefore it's in a loop
	2417	// and the light parameters are updated once per traversal through the
	2418	// loop
	2419	const LightList& rendLightList = rend->getLights();
	2420	bool iteratePerLight = pass->getIteratePerLight();
	2421	size_t numIterations = iteratePerLight ? rendLightList.size() : 1;
	2422	const LightList* pLightListToUse;
	2423	for (size_t i = 0; i < numIterations; ++i)
	2424	{
	2425	// Determine light list to use
	2426	if (iteratePerLight)
	2427	{
	2428	// Change the only element of local light list to be
	2429	// the light at index i
	2430	localLightList.clear();
	2431	// Check whether we need to filter this one out
	2432	if (pass->getRunOnlyForOneLightType() &&
	2433	pass->getOnlyLightType() != rendLightList[i]->getType())
	2434	{
	2435	// Skip
	2436	continue;
	2437	}
	2438
	2439	localLightList.push_back(rendLightList[i]);
	2440	pLightListToUse = &localLightList;
	2441	}
	2442	else
	2443	{
	2444	// Use complete light list
	2445	pLightListToUse = &rendLightList;
	2446	}
	2447
	2448
	2449	// Do we need to update GPU program parameters?
	2450	if (pass->isProgrammable())
	2451	{
	2452	// Update any automatic gpu params for lights
	2453	// Other bits of information will have to be looked up
	2454	mAutoParamDataSource.setCurrentLightList(pLightListToUse);
	2455	pass->_updateAutoParamsLightsOnly(mAutoParamDataSource);
	2456	// NOTE: We MUST bind parameters AFTER updating the autos
	2457	// TEST
	2458	if (pass->hasVertexProgram())
	2459	{
	2460	mDestRenderSystem->bindGpuProgramParameters(GPT_VERTEX_PROGRAM,
	2461	pass->getVertexProgramParameters());
	2462	}
	2463	if (pass->hasFragmentProgram())
	2464	{
	2465	mDestRenderSystem->bindGpuProgramParameters(GPT_FRAGMENT_PROGRAM,
	2466	pass->getFragmentProgramParameters());
	2467	}
	2468	}
	2469	// Do we need to update light states?
	2470	// Only do this if fixed-function vertex lighting applies
	2471	if (pass->getLightingEnabled() && passSurfaceAndLightParams)
	2472	{
	2473	mDestRenderSystem->_useLights(*pLightListToUse, pass->getMaxSimultaneousLights());
	2474	}
	2475	// issue the render op
	2476	// nfz: check for gpu_multipass
	2477	mDestRenderSystem->setCurrentPassIterationCount(pass->getPassIterationCount());
	2478	mDestRenderSystem->_render(ro);
	2479	} // possibly iterate per light
	2480	}
	2481	else // no automatic light processing
	2482	{
	2483	// Do we need to update GPU program parameters?
	2484	if (pass->isProgrammable())
	2485	{
	2486	// Do we have a manual light list?
	2487	if (manualLightList)
	2488	{
	2489	// Update any automatic gpu params for lights
	2490	mAutoParamDataSource.setCurrentLightList(manualLightList);
	2491	pass->_updateAutoParamsLightsOnly(mAutoParamDataSource);
	2492	}
	2493
	2494	if (pass->hasVertexProgram())
	2495	{
	2496	mDestRenderSystem->bindGpuProgramParameters(GPT_VERTEX_PROGRAM,
	2497	pass->getVertexProgramParameters());
	2498	}
	2499	if (pass->hasFragmentProgram())
	2500	{
	2501	mDestRenderSystem->bindGpuProgramParameters(GPT_FRAGMENT_PROGRAM,
	2502	pass->getFragmentProgramParameters());
	2503	}
	2504	}
	2505
	2506	// Use manual lights if present, and not using vertex programs that don't use fixed pipeline
	2507	if (manualLightList &&
	2508	pass->getLightingEnabled() && passSurfaceAndLightParams)
	2509	{
	2510	mDestRenderSystem->_useLights(*manualLightList, pass->getMaxSimultaneousLights());
	2511	}
	2512	// issue the render op
	2513	// nfz: set up multipass rendering
	2514	mDestRenderSystem->setCurrentPassIterationCount(pass->getPassIterationCount());
	2515	mDestRenderSystem->_render(ro);
	2516	}
	2517
	2518	}
	2519	else // mSuppressRenderStateChanges
	2520	{
	2521	// Just render
	2522	mDestRenderSystem->setCurrentPassIterationCount(1);
	2523	mDestRenderSystem->_render(ro);
	2524	}
	2525
	2526	// Reset view / projection changes if any
	2527	resetViewProjMode();
	2528
	2529	}
	2530	//-----------------------------------------------------------------------
	2531	void SceneManager::setAmbientLight(const ColourValue& colour)
	2532	{
	2533	mAmbientLight = colour;
	2534	}
	2535	//-----------------------------------------------------------------------
	2536	const ColourValue& SceneManager::getAmbientLight(void) const
	2537	{
	2538	return mAmbientLight;
	2539	}
	2540	//-----------------------------------------------------------------------
	2541	ViewPoint SceneManager::getSuggestedViewpoint(bool random)
	2542	{
	2543	// By default return the origin
	2544	ViewPoint vp;
	2545	vp.position = Vector3::ZERO;
	2546	vp.orientation = Quaternion::IDENTITY;
	2547	return vp;
	2548	}
	2549	//-----------------------------------------------------------------------
	2550	void SceneManager::setFog(FogMode mode, const ColourValue& colour, Real density, Real start, Real end)
	2551	{
	2552	mFogMode = mode;
	2553	mFogColour = colour;
	2554	mFogStart = start;
	2555	mFogEnd = end;
	2556	mFogDensity = density;
	2557	}
	2558	//-----------------------------------------------------------------------
	2559	FogMode SceneManager::getFogMode(void) const
	2560	{
	2561	return mFogMode;
	2562	}
	2563	//-----------------------------------------------------------------------
	2564	const ColourValue& SceneManager::getFogColour(void) const
	2565	{
	2566	return mFogColour;
	2567	}
	2568	//-----------------------------------------------------------------------
	2569	Real SceneManager::getFogStart(void) const
	2570	{
	2571	return mFogStart;
	2572	}
	2573	//-----------------------------------------------------------------------
	2574	Real SceneManager::getFogEnd(void) const
	2575	{
	2576	return mFogEnd;
	2577	}
	2578	//-----------------------------------------------------------------------
	2579	Real SceneManager::getFogDensity(void) const
	2580	{
	2581	return mFogDensity;
	2582	}
	2583	//-----------------------------------------------------------------------
	2584	BillboardSet* SceneManager::createBillboardSet(const String& name, unsigned int poolSize)
	2585	{
	2586	NameValuePairList params;
	2587	params["poolSize"] = StringConverter::toString(poolSize);
	2588	return static_cast<BillboardSet*>(
	2589	createMovableObject(name, BillboardSetFactory::FACTORY_TYPE_NAME, &params));
	2590	}
	2591	//-----------------------------------------------------------------------
	2592	BillboardSet* SceneManager::getBillboardSet(const String& name)
	2593	{
	2594	return static_cast<BillboardSet*>(
	2595	getMovableObject(name, BillboardSetFactory::FACTORY_TYPE_NAME));
	2596	}
	2597	//-----------------------------------------------------------------------
	2598	void SceneManager::destroyBillboardSet(BillboardSet* set)
	2599	{
	2600	destroyMovableObject(set);
	2601	}
	2602	//-----------------------------------------------------------------------
	2603	void SceneManager::destroyBillboardSet(const String& name)
	2604	{
	2605	destroyMovableObject(name, BillboardSetFactory::FACTORY_TYPE_NAME);
	2606	}
	2607	//-----------------------------------------------------------------------
	2608	void SceneManager::setDisplaySceneNodes(bool display)
	2609	{
	2610	mDisplayNodes = display;
	2611	}
	2612	//-----------------------------------------------------------------------
	2613	Animation* SceneManager::createAnimation(const String& name, Real length)
	2614	{
	2615	// Check name not used
	2616	if (mAnimationsList.find(name) != mAnimationsList.end())
	2617	{
	2618	OGRE_EXCEPT(
	2619	Exception::ERR_DUPLICATE_ITEM,
	2620	"An animation with the name " + name + " already exists",
	2621	"SceneManager::createAnimation" );
	2622	}
	2623
	2624	Animation* pAnim = new Animation(name, length);
	2625	mAnimationsList[name] = pAnim;
	2626	return pAnim;
	2627	}
	2628	//-----------------------------------------------------------------------
	2629	Animation* SceneManager::getAnimation(const String& name) const
	2630	{
	2631	AnimationList::const_iterator i = mAnimationsList.find(name);
	2632	if (i == mAnimationsList.end())
	2633	{
	2634	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	2635	"Cannot find animation with name " + name,
	2636	"SceneManager::getAnimation");
	2637	}
	2638	return i->second;
	2639	}
	2640	//-----------------------------------------------------------------------
	2641	void SceneManager::destroyAnimation(const String& name)
	2642	{
	2643	// Also destroy any animation states referencing this animation
	2644	mAnimationStates.removeAnimationState(name);
	2645
	2646	AnimationList::iterator i = mAnimationsList.find(name);
	2647	if (i == mAnimationsList.end())
	2648	{
	2649	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	2650	"Cannot find animation with name " + name,
	2651	"SceneManager::getAnimation");
	2652	}
	2653
	2654	// Free memory
	2655	delete i->second;
	2656
	2657	mAnimationsList.erase(i);
	2658
	2659
	2660	}
	2661	//-----------------------------------------------------------------------
	2662	void SceneManager::destroyAllAnimations(void)
	2663	{
	2664	// Destroy all states too, since they cannot reference destroyed animations
	2665	destroyAllAnimationStates();
	2666
	2667	AnimationList::iterator i;
	2668	for (i = mAnimationsList.begin(); i != mAnimationsList.end(); ++i)
	2669	{
	2670	// destroy
	2671	delete i->second;
	2672	}
	2673	mAnimationsList.clear();
	2674	}
	2675	//-----------------------------------------------------------------------
	2676	AnimationState* SceneManager::createAnimationState(const String& animName)
	2677	{
	2678
	2679	// Get animation, this will throw an exception if not found
	2680	Animation* anim = getAnimation(animName);
	2681
	2682	// Create new state
	2683	return mAnimationStates.createAnimationState(animName, 0, anim->getLength());
	2684
	2685	}
	2686	//-----------------------------------------------------------------------
	2687	AnimationState* SceneManager::getAnimationState(const String& animName)
	2688	{
	2689	return mAnimationStates.getAnimationState(animName);
	2690
	2691	}
	2692	//-----------------------------------------------------------------------
	2693	void SceneManager::destroyAnimationState(const String& name)
	2694	{
	2695	mAnimationStates.removeAnimationState(name);
	2696	}
	2697	//-----------------------------------------------------------------------
	2698	void SceneManager::destroyAllAnimationStates(void)
	2699	{
	2700	mAnimationStates.removeAllAnimationStates();
	2701	}
	2702	//-----------------------------------------------------------------------
	2703	void SceneManager::_applySceneAnimations(void)
	2704	{
	2705	ConstEnabledAnimationStateIterator stateIt = mAnimationStates.getEnabledAnimationStateIterator();
	2706
	2707	while (stateIt.hasMoreElements())
	2708	{
	2709	const AnimationState* state = stateIt.getNext();
	2710	Animation* anim = getAnimation(state->getAnimationName());
	2711
	2712	// Reset any nodes involved
	2713	// NB this excludes blended animations
	2714	Animation::NodeTrackIterator nodeTrackIt = anim->getNodeTrackIterator();
	2715	while(nodeTrackIt.hasMoreElements())
	2716	{
	2717	Node* nd = nodeTrackIt.getNext()->getAssociatedNode();
	2718	nd->resetToInitialState();
	2719	}
	2720
	2721	Animation::NumericTrackIterator numTrackIt = anim->getNumericTrackIterator();
	2722	while(numTrackIt.hasMoreElements())
	2723	{
	2724	numTrackIt.getNext()->getAssociatedAnimable()->resetToBaseValue();
	2725	}
	2726
	2727	// Apply the animation
	2728	anim->apply(state->getTimePosition(), state->getWeight());
	2729	}
	2730
	2731
	2732	}
	2733	//---------------------------------------------------------------------
	2734	void SceneManager::manualRender(RenderOperation* rend,
	2735	Pass* pass, Viewport* vp, const Matrix4& worldMatrix,
	2736	const Matrix4& viewMatrix, const Matrix4& projMatrix,
	2737	bool doBeginEndFrame)
	2738	{
	2739	mDestRenderSystem->_setViewport(vp);
	2740	mDestRenderSystem->_setWorldMatrix(worldMatrix);
	2741	mDestRenderSystem->_setViewMatrix(viewMatrix);
	2742	mDestRenderSystem->_setProjectionMatrix(projMatrix);
	2743
	2744	if (doBeginEndFrame)
	2745	mDestRenderSystem->_beginFrame();
	2746
	2747	_setPass(pass);
	2748	mDestRenderSystem->_render(*rend);
	2749
	2750	if (doBeginEndFrame)
	2751	mDestRenderSystem->_endFrame();
	2752
	2753	}
	2754	//---------------------------------------------------------------------
	2755	void SceneManager::useRenderableViewProjMode(const Renderable* pRend)
	2756	{
	2757	// Check view matrix
	2758	bool useIdentityView = pRend->useIdentityView();
	2759	if (useIdentityView)
	2760	{
	2761	// Using identity view now, change it
	2762	mDestRenderSystem->_setViewMatrix(Matrix4::IDENTITY);
	2763	mResetIdentityView = true;
	2764	}
	2765
	2766	bool useIdentityProj = pRend->useIdentityProjection();
	2767	if (useIdentityProj)
	2768	{
	2769	// Use identity projection matrix, still need to take RS depth into account.
	2770	Matrix4 mat;
	2771	mDestRenderSystem->_convertProjectionMatrix(Matrix4::IDENTITY, mat);
	2772	mDestRenderSystem->_setProjectionMatrix(mat);
	2773
	2774	mResetIdentityProj = true;
	2775	}
	2776
	2777
	2778	}
	2779	//---------------------------------------------------------------------
	2780	void SceneManager::resetViewProjMode(void)
	2781	{
	2782	if (mResetIdentityView)
	2783	{
	2784	// Coming back to normal from identity view
	2785	mDestRenderSystem->_setViewMatrix(mCameraInProgress->getViewMatrix(true));
	2786	mResetIdentityView = false;
	2787	}
	2788
	2789	if (mResetIdentityProj)
	2790	{
	2791	// Coming back from flat projection
	2792	mDestRenderSystem->_setProjectionMatrix(mCameraInProgress->getProjectionMatrixRS());
	2793	mResetIdentityProj = false;
	2794	}
	2795
	2796
	2797	}
	2798	//---------------------------------------------------------------------
	2799	void SceneManager::_queueSkiesForRendering(Camera* cam)
	2800	{
	2801	// Update nodes
	2802	// Translate the box by the camera position (constant distance)
	2803	if (mSkyPlaneNode)
	2804	{
	2805	// The plane position relative to the camera has already been set up
	2806	mSkyPlaneNode->setPosition(cam->getDerivedPosition());
	2807	}
	2808
	2809	if (mSkyBoxNode)
	2810	{
	2811	mSkyBoxNode->setPosition(cam->getDerivedPosition());
	2812	}
	2813
	2814	if (mSkyDomeNode)
	2815	{
	2816	mSkyDomeNode->setPosition(cam->getDerivedPosition());
	2817	}
	2818
	2819	uint8 qid;
	2820	if (mSkyPlaneEnabled)
	2821	{
	2822	qid = mSkyPlaneDrawFirst?
	2823	RENDER_QUEUE_SKIES_EARLY : RENDER_QUEUE_SKIES_LATE;
	2824	getRenderQueue()->addRenderable(mSkyPlaneEntity->getSubEntity(0), qid, OGRE_RENDERABLE_DEFAULT_PRIORITY);
	2825	}
	2826
	2827	uint plane;
	2828	if (mSkyBoxEnabled)
	2829	{
	2830	qid = mSkyBoxDrawFirst?
	2831	RENDER_QUEUE_SKIES_EARLY : RENDER_QUEUE_SKIES_LATE;
	2832
	2833	for (plane = 0; plane < 6; ++plane)
	2834	{
	2835	getRenderQueue()->addRenderable(
	2836	mSkyBoxEntity[plane]->getSubEntity(0), qid, OGRE_RENDERABLE_DEFAULT_PRIORITY);
	2837	}
	2838	}
	2839
	2840	if (mSkyDomeEnabled)
	2841	{
	2842	qid = mSkyDomeDrawFirst?
	2843	RENDER_QUEUE_SKIES_EARLY : RENDER_QUEUE_SKIES_LATE;
	2844
	2845	for (plane = 0; plane < 5; ++plane)
	2846	{
	2847	getRenderQueue()->addRenderable(
	2848	mSkyDomeEntity[plane]->getSubEntity(0), qid, OGRE_RENDERABLE_DEFAULT_PRIORITY);
	2849	}
	2850	}
	2851	}
	2852	//---------------------------------------------------------------------
	2853	void SceneManager::addRenderQueueListener(RenderQueueListener* newListener)
	2854	{
	2855	mRenderQueueListeners.push_back(newListener);
	2856	}
	2857	//---------------------------------------------------------------------
	2858	void SceneManager::removeRenderQueueListener(RenderQueueListener* delListener)
	2859	{
	2860	RenderQueueListenerList::iterator i, iend;
	2861	iend = mRenderQueueListeners.end();
	2862	for (i = mRenderQueueListeners.begin(); i != iend; ++i)
	2863	{
	2864	if (*i == delListener)
	2865	{
	2866	mRenderQueueListeners.erase(i);
	2867	break;
	2868	}
	2869	}
	2870
	2871	}
	2872	//---------------------------------------------------------------------
	2873	void SceneManager::addShadowListener(ShadowListener* newListener)
	2874	{
	2875	mShadowListeners.push_back(newListener);
	2876	}
	2877	//---------------------------------------------------------------------
	2878	void SceneManager::removeShadowListener(ShadowListener* delListener)
	2879	{
	2880	ShadowListenerList::iterator i, iend;
	2881	iend = mShadowListeners.end();
	2882	for (i = mShadowListeners.begin(); i != iend; ++i)
	2883	{
	2884	if (*i == delListener)
	2885	{
	2886	mShadowListeners.erase(i);
	2887	break;
	2888	}
	2889	}
	2890
	2891	}
	2892	//---------------------------------------------------------------------
	2893	bool SceneManager::fireRenderQueueStarted(uint8 id, const String& invocation)
	2894	{
	2895	RenderQueueListenerList::iterator i, iend;
	2896	bool skip = false;
	2897
	2898	iend = mRenderQueueListeners.end();
	2899	for (i = mRenderQueueListeners.begin(); i != iend; ++i)
	2900	{
	2901	(*i)->renderQueueStarted(id, invocation, skip);
	2902	}
	2903	return skip;
	2904	}
	2905	//---------------------------------------------------------------------
	2906	bool SceneManager::fireRenderQueueEnded(uint8 id, const String& invocation)
	2907	{
	2908	RenderQueueListenerList::iterator i, iend;
	2909	bool repeat = false;
	2910
	2911	iend = mRenderQueueListeners.end();
	2912	for (i = mRenderQueueListeners.begin(); i != iend; ++i)
	2913	{
	2914	(*i)->renderQueueEnded(id, invocation, repeat);
	2915	}
	2916	return repeat;
	2917	}
	2918	//---------------------------------------------------------------------
	2919	void SceneManager::fireShadowTexturesUpdated(size_t numberOfShadowTextures)
	2920	{
	2921	ShadowListenerList::iterator i, iend;
	2922
	2923	iend = mShadowListeners.end();
	2924	for (i = mShadowListeners.begin(); i != iend; ++i)
	2925	{
	2926	(*i)->shadowTexturesUpdated(numberOfShadowTextures);
	2927	}
	2928	}
	2929	//---------------------------------------------------------------------
	2930	void SceneManager::fireShadowTexturesPreCaster(Light* light, Camera* camera)
	2931	{
	2932	ShadowListenerList::iterator i, iend;
	2933
	2934	iend = mShadowListeners.end();
	2935	for (i = mShadowListeners.begin(); i != iend; ++i)
	2936	{
	2937	(*i)->shadowTextureCasterPreViewProj(light, camera);
	2938	}
	2939	}
	2940	//---------------------------------------------------------------------
	2941	void SceneManager::fireShadowTexturesPreReceiver(Light* light, Frustum* f)
	2942	{
	2943	ShadowListenerList::iterator i, iend;
	2944
	2945	iend = mShadowListeners.end();
	2946	for (i = mShadowListeners.begin(); i != iend; ++i)
	2947	{
	2948	(*i)->shadowTextureReceiverPreViewProj(light, f);
	2949	}
	2950	}
	2951	//---------------------------------------------------------------------
	2952	void SceneManager::setViewport(Viewport* vp)
	2953	{
	2954	mCurrentViewport = vp;
	2955	// Set viewport in render system
	2956	mDestRenderSystem->_setViewport(vp);
	2957	// Set the active material scheme for this viewport
	2958	MaterialManager::getSingleton().setActiveScheme(vp->getMaterialScheme());
	2959	}
	2960	//---------------------------------------------------------------------
	2961	void SceneManager::showBoundingBoxes(bool bShow)
	2962	{
	2963	mShowBoundingBoxes = bShow;
	2964	}
	2965	//---------------------------------------------------------------------
	2966	bool SceneManager::getShowBoundingBoxes() const
	2967	{
	2968	return mShowBoundingBoxes;
	2969	}
	2970	//---------------------------------------------------------------------
	2971	void SceneManager::_notifyAutotrackingSceneNode(SceneNode* node, bool autoTrack)
	2972	{
	2973	if (autoTrack)
	2974	{
	2975	mAutoTrackingSceneNodes.insert(node);
	2976	}
	2977	else
	2978	{
	2979	mAutoTrackingSceneNodes.erase(node);
	2980	}
	2981	}
	2982	//---------------------------------------------------------------------
	2983	void SceneManager::setShadowTechnique(ShadowTechnique technique)
	2984	{
	2985	mShadowTechnique = technique;
	2986	if (isShadowTechniqueStencilBased())
	2987	{
	2988	// Firstly check that we have a stencil
	2989	// Otherwise forget it
	2990	if (!mDestRenderSystem->getCapabilities()->hasCapability(RSC_HWSTENCIL))
	2991	{
	2992	LogManager::getSingleton().logMessage(
	2993	"WARNING: Stencil shadows were requested, but this device does not "
	2994	"have a hardware stencil. Shadows disabled.");
	2995	mShadowTechnique = SHADOWTYPE_NONE;
	2996	}
	2997	else if (mShadowIndexBuffer.isNull())
	2998	{
	2999	// Create an estimated sized shadow index buffer
	3000	mShadowIndexBuffer = HardwareBufferManager::getSingleton().
	3001	createIndexBuffer(HardwareIndexBuffer::IT_16BIT,
	3002	mShadowIndexBufferSize,
	3003	HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE,
	3004	false);
	3005	// tell all meshes to prepare shadow volumes
	3006	MeshManager::getSingleton().setPrepareAllMeshesForShadowVolumes(true);
	3007	}
	3008	}
	3009
	3010	if (isShadowTechniqueTextureBased())
	3011	{
	3012	createShadowTextures(mShadowTextureSize, mShadowTextureCount, mShadowTextureFormat);
	3013	}
	3014	else
	3015	{
	3016	// Destroy shadow textures to optimise resource usage
	3017	destroyShadowTextures();
	3018	}
	3019
	3020	}
	3021	//---------------------------------------------------------------------
	3022	void SceneManager::_suppressShadows(bool suppress)
	3023	{
	3024	mSuppressShadows = suppress;
	3025	}
	3026	//---------------------------------------------------------------------
	3027	void SceneManager::_suppressRenderStateChanges(bool suppress)
	3028	{
	3029	mSuppressRenderStateChanges = suppress;
	3030	}
	3031	//---------------------------------------------------------------------
	3032	void SceneManager::updateRenderQueueSplitOptions(void)
	3033	{
	3034	if (isShadowTechniqueStencilBased())
	3035	{
	3036	// Casters can always be receivers
	3037	getRenderQueue()->setShadowCastersCannotBeReceivers(false);
	3038	}
	3039	else // texture based
	3040	{
	3041	getRenderQueue()->setShadowCastersCannotBeReceivers(!mShadowTextureSelfShadow);
	3042	}
	3043
	3044	if (isShadowTechniqueAdditive() && mCurrentViewport->getShadowsEnabled())
	3045	{
	3046	// Additive lighting, we need to split everything by illumination stage
	3047	getRenderQueue()->setSplitPassesByLightingType(true);
	3048	}
	3049	else
	3050	{
	3051	getRenderQueue()->setSplitPassesByLightingType(false);
	3052	}
	3053
	3054	if (isShadowTechniqueInUse() && mCurrentViewport->getShadowsEnabled())
	3055	{
	3056	// Tell render queue to split off non-shadowable materials
	3057	getRenderQueue()->setSplitNoShadowPasses(true);
	3058	}
	3059	else
	3060	{
	3061	getRenderQueue()->setSplitNoShadowPasses(false);
	3062	}
	3063
	3064
	3065	}
	3066	//---------------------------------------------------------------------
	3067	void SceneManager::updateRenderQueueGroupSplitOptions(RenderQueueGroup* group,
	3068	bool suppressShadows, bool suppressRenderState)
	3069	{
	3070	if (isShadowTechniqueStencilBased())
	3071	{
	3072	// Casters can always be receivers
	3073	group->setShadowCastersCannotBeReceivers(false);
	3074	}
	3075	else if (isShadowTechniqueTextureBased())
	3076	{
	3077	group->setShadowCastersCannotBeReceivers(!mShadowTextureSelfShadow);
	3078	}
	3079
	3080	if (!suppressShadows && mCurrentViewport->getShadowsEnabled() &&
	3081	isShadowTechniqueAdditive())
	3082	{
	3083	// Additive lighting, we need to split everything by illumination stage
	3084	group->setSplitPassesByLightingType(true);
	3085	}
	3086	else
	3087	{
	3088	group->setSplitPassesByLightingType(false);
	3089	}
	3090
	3091	if (!suppressShadows && mCurrentViewport->getShadowsEnabled()
	3092	&& isShadowTechniqueInUse())
	3093	{
	3094	// Tell render queue to split off non-shadowable materials
	3095	group->setSplitNoShadowPasses(true);
	3096	}
	3097	else
	3098	{
	3099	group->setSplitNoShadowPasses(false);
	3100	}
	3101
	3102
	3103	}
	3104	//---------------------------------------------------------------------
	3105	void SceneManager::findLightsAffectingFrustum(const Camera* camera)
	3106	{
	3107	// Basic iteration for this SM
	3108	mLightsAffectingFrustum.clear();
	3109	Sphere sphere;
	3110	MovableObjectIterator it =
	3111	getMovableObjectIterator(LightFactory::FACTORY_TYPE_NAME);
	3112	while(it.hasMoreElements())
	3113	{
	3114	Light* l = static_cast<Light*>(it.getNext());
	3115	if (l->isVisible())
	3116	{
	3117	if (l->getType() == Light::LT_DIRECTIONAL)
	3118	{
	3119	// Always visible
	3120	mLightsAffectingFrustum.push_back(l);
	3121	}
	3122	else
	3123	{
	3124	// NB treating spotlight as point for simplicity
	3125	// Just see if the lights attenuation range is within the frustum
	3126	sphere.setCenter(l->getDerivedPosition());
	3127	sphere.setRadius(l->getAttenuationRange());
	3128	if (camera->isVisible(sphere))
	3129	{
	3130	mLightsAffectingFrustum.push_back(l);
	3131	}
	3132
	3133	}
	3134	}
	3135	}
	3136
	3137	}
	3138	//---------------------------------------------------------------------
	3139	bool SceneManager::ShadowCasterSceneQueryListener::queryResult(
	3140	MovableObject* object)
	3141	{
	3142	if (object->getCastShadows() && object->isVisible() &&
	3143	mSceneMgr->isRenderQueueToBeProcessed(object->getRenderQueueGroup()))
	3144	{
	3145	if (mFarDistSquared)
	3146	{
	3147	// Check object is within the shadow far distance
	3148	Vector3 toObj = object->getParentNode()->_getDerivedPosition()
	3149	- mCamera->getDerivedPosition();
	3150	Real radius = object->getWorldBoundingSphere().getRadius();
	3151	Real dist = toObj.squaredLength();
	3152	if (dist - (radius * radius) > mFarDistSquared)
	3153	{
	3154	// skip, beyond max range
	3155	return true;
	3156	}
	3157	}
	3158
	3159	// If the object is in the frustum, we can always see the shadow
	3160	if (mCamera->isVisible(object->getWorldBoundingBox()))
	3161	{
	3162	mCasterList->push_back(object);
	3163	return true;
	3164	}
	3165
	3166	// Otherwise, object can only be casting a shadow into our view if
	3167	// the light is outside the frustum (or it's a directional light,
	3168	// which are always outside), and the object is intersecting
	3169	// on of the volumes formed between the edges of the frustum and the
	3170	// light
	3171	if (!mIsLightInFrustum \|\| mLight->getType() == Light::LT_DIRECTIONAL)
	3172	{
	3173	// Iterate over volumes
	3174	PlaneBoundedVolumeList::const_iterator i, iend;
	3175	iend = mLightClipVolumeList->end();
	3176	for (i = mLightClipVolumeList->begin(); i != iend; ++i)
	3177	{
	3178	if (i->intersects(object->getWorldBoundingBox()))
	3179	{
	3180	mCasterList->push_back(object);
	3181	return true;
	3182	}
	3183
	3184	}
	3185
	3186	}
	3187	}
	3188	return true;
	3189	}
	3190	//---------------------------------------------------------------------
	3191	bool SceneManager::ShadowCasterSceneQueryListener::queryResult(
	3192	SceneQuery::WorldFragment* fragment)
	3193	{
	3194	// don't deal with world geometry
	3195	return true;
	3196	}
	3197	//---------------------------------------------------------------------
	3198	const SceneManager::ShadowCasterList& SceneManager::findShadowCastersForLight(
	3199	const Light* light, const Camera* camera)
	3200	{
	3201	mShadowCasterList.clear();
	3202
	3203	if (light->getType() == Light::LT_DIRECTIONAL)
	3204	{
	3205	// Basic AABB query encompassing the frustum and the extrusion of it
	3206	AxisAlignedBox aabb;
	3207	const Vector3* corners = camera->getWorldSpaceCorners();
	3208	Vector3 min, max;
	3209	Vector3 extrude = light->getDerivedDirection() * -mShadowDirLightExtrudeDist;
	3210	// do first corner
	3211	min = max = corners[0];
	3212	min.makeFloor(corners[0] + extrude);
	3213	max.makeCeil(corners[0] + extrude);
	3214	for (size_t c = 1; c < 8; ++c)
	3215	{
	3216	min.makeFloor(corners[c]);
	3217	max.makeCeil(corners[c]);
	3218	min.makeFloor(corners[c] + extrude);
	3219	max.makeCeil(corners[c] + extrude);
	3220	}
	3221	aabb.setExtents(min, max);
	3222
	3223	if (!mShadowCasterAABBQuery)
	3224	mShadowCasterAABBQuery = createAABBQuery(aabb);
	3225	else
	3226	mShadowCasterAABBQuery->setBox(aabb);
	3227	// Execute, use callback
	3228	mShadowCasterQueryListener->prepare(false,
	3229	&(light->_getFrustumClipVolumes(camera)),
	3230	light, camera, &mShadowCasterList, mShadowFarDistSquared);
	3231	mShadowCasterAABBQuery->execute(mShadowCasterQueryListener);
	3232
	3233
	3234	}
	3235	else
	3236	{
	3237	Sphere s(light->getDerivedPosition(), light->getAttenuationRange());
	3238	// eliminate early if camera cannot see light sphere
	3239	if (camera->isVisible(s))
	3240	{
	3241	if (!mShadowCasterSphereQuery)
	3242	mShadowCasterSphereQuery = createSphereQuery(s);
	3243	else
	3244	mShadowCasterSphereQuery->setSphere(s);
	3245
	3246	// Determine if light is inside or outside the frustum
	3247	bool lightInFrustum = camera->isVisible(light->getDerivedPosition());
	3248	const PlaneBoundedVolumeList* volList = 0;
	3249	if (!lightInFrustum)
	3250	{
	3251	// Only worth building an external volume list if
	3252	// light is outside the frustum
	3253	volList = &(light->_getFrustumClipVolumes(camera));
	3254	}
	3255
	3256	// Execute, use callback
	3257	mShadowCasterQueryListener->prepare(lightInFrustum,
	3258	volList, light, camera, &mShadowCasterList, mShadowFarDistSquared);
	3259	mShadowCasterSphereQuery->execute(mShadowCasterQueryListener);
	3260
	3261	}
	3262
	3263	}
	3264
	3265
	3266	return mShadowCasterList;
	3267	}
	3268	//---------------------------------------------------------------------
	3269	void SceneManager::initShadowVolumeMaterials(void)
	3270	{
	3271	/* This should have been set in the SceneManager constructor, but if you
	3272	created the SceneManager BEFORE the Root object, you will need to call
	3273	SceneManager::_setDestinationRenderSystem manually.
	3274	*/
	3275	assert( mDestRenderSystem );
	3276
	3277	if (mShadowMaterialInitDone)
	3278	return;
	3279
	3280	if (!mShadowDebugPass)
	3281	{
	3282	MaterialPtr matDebug =
	3283	MaterialManager::getSingleton().getByName("Ogre/Debug/ShadowVolumes");
	3284	if (matDebug.isNull())
	3285	{
	3286	// Create
	3287	matDebug = MaterialManager::getSingleton().create(
	3288	"Ogre/Debug/ShadowVolumes",
	3289	ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
	3290	mShadowDebugPass = matDebug->getTechnique(0)->getPass(0);
	3291	mShadowDebugPass->setSceneBlending(SBT_ADD);
	3292	mShadowDebugPass->setLightingEnabled(false);
	3293	mShadowDebugPass->setDepthWriteEnabled(false);
	3294	TextureUnitState* t = mShadowDebugPass->createTextureUnitState();
	3295	t->setColourOperationEx(LBX_MODULATE, LBS_MANUAL, LBS_CURRENT,
	3296	ColourValue(0.7, 0.0, 0.2));
	3297	mShadowDebugPass->setCullingMode(CULL_NONE);
	3298
	3299	if (mDestRenderSystem->getCapabilities()->hasCapability(
	3300	RSC_VERTEX_PROGRAM))
	3301	{
	3302	ShadowVolumeExtrudeProgram::initialise();
	3303
	3304	// Enable the (infinite) point light extruder for now, just to get some params
	3305	mShadowDebugPass->setVertexProgram(
	3306	ShadowVolumeExtrudeProgram::programNames[ShadowVolumeExtrudeProgram::POINT_LIGHT]);
	3307	mInfiniteExtrusionParams =
	3308	mShadowDebugPass->getVertexProgramParameters();
	3309	mInfiniteExtrusionParams->setAutoConstant(0,
	3310	GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
	3311	mInfiniteExtrusionParams->setAutoConstant(4,
	3312	GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE);
	3313	}
	3314	matDebug->compile();
	3315
	3316	}
	3317	else
	3318	{
	3319	mShadowDebugPass = matDebug->getTechnique(0)->getPass(0);
	3320
	3321	if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM))
	3322	{
	3323	mInfiniteExtrusionParams = mShadowDebugPass->getVertexProgramParameters();
	3324	}
	3325	}
	3326	}
	3327
	3328	if (!mShadowStencilPass)
	3329	{
	3330
	3331	MaterialPtr matStencil = MaterialManager::getSingleton().getByName(
	3332	"Ogre/StencilShadowVolumes");
	3333	if (matStencil.isNull())
	3334	{
	3335	// Init
	3336	matStencil = MaterialManager::getSingleton().create(
	3337	"Ogre/StencilShadowVolumes",
	3338	ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
	3339	mShadowStencilPass = matStencil->getTechnique(0)->getPass(0);
	3340
	3341	if (mDestRenderSystem->getCapabilities()->hasCapability(
	3342	RSC_VERTEX_PROGRAM))
	3343	{
	3344
	3345	// Enable the finite point light extruder for now, just to get some params
	3346	mShadowStencilPass->setVertexProgram(
	3347	ShadowVolumeExtrudeProgram::programNames[ShadowVolumeExtrudeProgram::POINT_LIGHT_FINITE]);
	3348	mFiniteExtrusionParams =
	3349	mShadowStencilPass->getVertexProgramParameters();
	3350	mFiniteExtrusionParams->setAutoConstant(0,
	3351	GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX);
	3352	mFiniteExtrusionParams->setAutoConstant(4,
	3353	GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE);
	3354	// Note extra parameter
	3355	mFiniteExtrusionParams->setAutoConstant(5,
	3356	GpuProgramParameters::ACT_SHADOW_EXTRUSION_DISTANCE);
	3357	}
	3358	matStencil->compile();
	3359	// Nothing else, we don't use this like a 'real' pass anyway,
	3360	// it's more of a placeholder
	3361	}
	3362	else
	3363	{
	3364	mShadowStencilPass = matStencil->getTechnique(0)->getPass(0);
	3365
	3366	if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM))
	3367	{
	3368	mFiniteExtrusionParams = mShadowStencilPass->getVertexProgramParameters();
	3369	}
	3370	}
	3371	}
	3372
	3373
	3374
	3375
	3376	if (!mShadowModulativePass)
	3377	{
	3378
	3379	MaterialPtr matModStencil = MaterialManager::getSingleton().getByName(
	3380	"Ogre/StencilShadowModulationPass");
	3381	if (matModStencil.isNull())
	3382	{
	3383	// Init
	3384	matModStencil = MaterialManager::getSingleton().create(
	3385	"Ogre/StencilShadowModulationPass",
	3386	ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
	3387	mShadowModulativePass = matModStencil->getTechnique(0)->getPass(0);
	3388	mShadowModulativePass->setSceneBlending(SBF_DEST_COLOUR, SBF_ZERO);
	3389	mShadowModulativePass->setLightingEnabled(false);
	3390	mShadowModulativePass->setDepthWriteEnabled(false);
	3391	mShadowModulativePass->setDepthCheckEnabled(false);
	3392	TextureUnitState* t = mShadowModulativePass->createTextureUnitState();
	3393	t->setColourOperationEx(LBX_MODULATE, LBS_MANUAL, LBS_CURRENT,
	3394	mShadowColour);
	3395	mShadowModulativePass->setCullingMode(CULL_NONE);
	3396	}
	3397	else
	3398	{
	3399	mShadowModulativePass = matModStencil->getTechnique(0)->getPass(0);
	3400	}
	3401	}
	3402
	3403	// Also init full screen quad while we're at it
	3404	if (!mFullScreenQuad)
	3405	{
	3406	mFullScreenQuad = new Rectangle2D();
	3407	mFullScreenQuad->setCorners(-1,1,1,-1);
	3408	}
	3409
	3410	// Also init shadow caster material for texture shadows
	3411	if (!mShadowCasterPlainBlackPass)
	3412	{
	3413	MaterialPtr matPlainBlack = MaterialManager::getSingleton().getByName(
	3414	"Ogre/TextureShadowCaster");
	3415	if (matPlainBlack.isNull())
	3416	{
	3417	matPlainBlack = MaterialManager::getSingleton().create(
	3418	"Ogre/TextureShadowCaster",
	3419	ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
	3420	mShadowCasterPlainBlackPass = matPlainBlack->getTechnique(0)->getPass(0);
	3421	// Lighting has to be on, because we need shadow coloured objects
	3422	// Note that because we can't predict vertex programs, we'll have to
	3423	// bind light values to those, and so we bind White to ambient
	3424	// reflectance, and we'll set the ambient colour to the shadow colour
	3425	mShadowCasterPlainBlackPass->setAmbient(ColourValue::White);
	3426	mShadowCasterPlainBlackPass->setDiffuse(ColourValue::Black);
	3427	mShadowCasterPlainBlackPass->setSelfIllumination(ColourValue::Black);
	3428	mShadowCasterPlainBlackPass->setSpecular(ColourValue::Black);
	3429	// Override fog
	3430	mShadowCasterPlainBlackPass->setFog(true, FOG_NONE);
	3431	// no textures or anything else, we will bind vertex programs
	3432	// every so often though
	3433	}
	3434	else
	3435	{
	3436	mShadowCasterPlainBlackPass = matPlainBlack->getTechnique(0)->getPass(0);
	3437	}
	3438	}
	3439
	3440	if (!mShadowReceiverPass)
	3441	{
	3442	MaterialPtr matShadRec = MaterialManager::getSingleton().getByName(
	3443	"Ogre/TextureShadowReceiver");
	3444	if (matShadRec.isNull())
	3445	{
	3446	matShadRec = MaterialManager::getSingleton().create(
	3447	"Ogre/TextureShadowReceiver",
	3448	ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
	3449	mShadowReceiverPass = matShadRec->getTechnique(0)->getPass(0);
	3450	// Don't set lighting and blending modes here, depends on additive / modulative
	3451	TextureUnitState* t = mShadowReceiverPass->createTextureUnitState();
	3452	t->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
	3453	}
	3454	else
	3455	{
	3456	mShadowReceiverPass = matShadRec->getTechnique(0)->getPass(0);
	3457	}
	3458	}
	3459
	3460	// Set up spot shadow fade texture (loaded from code data block)
	3461	TexturePtr spotShadowFadeTex =
	3462	TextureManager::getSingleton().getByName("spot_shadow_fade.png");
	3463	if (spotShadowFadeTex.isNull())
	3464	{
	3465	// Load the manual buffer into an image (don't destroy memory!
	3466	DataStreamPtr stream(
	3467	new MemoryDataStream(SPOT_SHADOW_FADE_PNG, SPOT_SHADOW_FADE_PNG_SIZE, false));
	3468	Image img;
	3469	img.load(stream, "png");
	3470	spotShadowFadeTex =
	3471	TextureManager::getSingleton().loadImage(
	3472	"spot_shadow_fade.png", ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME,
	3473	img, TEX_TYPE_2D);
	3474	}
	3475
	3476	mShadowMaterialInitDone = true;
	3477	}
	3478	//---------------------------------------------------------------------
	3479	const Pass* SceneManager::deriveShadowCasterPass(const Pass* pass)
	3480	{
	3481	if (isShadowTechniqueTextureBased())
	3482	{
	3483	Pass* retPass = mShadowTextureCustomCasterPass ?
	3484	mShadowTextureCustomCasterPass : mShadowCasterPlainBlackPass;
	3485
	3486
	3487	// Special case alpha-blended passes
	3488	if ((pass->getSourceBlendFactor() == SBF_SOURCE_ALPHA &&
	3489	pass->getDestBlendFactor() == SBF_ONE_MINUS_SOURCE_ALPHA)
	3490	\|\| pass->getAlphaRejectFunction() != CMPF_ALWAYS_PASS)
	3491	{
	3492	// Alpha blended passes must retain their transparency
	3493	retPass->setAlphaRejectSettings(pass->getAlphaRejectFunction(),
	3494	pass->getAlphaRejectValue());
	3495	retPass->setSceneBlending(pass->getSourceBlendFactor(), pass->getDestBlendFactor());
	3496	retPass->getParent()->getParent()->setTransparencyCastsShadows(true);
	3497
	3498	// So we allow the texture units, but override the colour functions
	3499	// Copy texture state, shift up one since 0 is shadow texture
	3500	size_t origPassTUCount = pass->getNumTextureUnitStates();
	3501	for (size_t t = 0; t < origPassTUCount; ++t)
	3502	{
	3503	TextureUnitState* tex;
	3504	if (retPass->getNumTextureUnitStates() <= t)
	3505	{
	3506	tex = retPass->createTextureUnitState();
	3507	}
	3508	else
	3509	{
	3510	tex = retPass->getTextureUnitState(t);
	3511	}
	3512	// copy base state
	3513	(tex) = (pass->getTextureUnitState(t));
	3514	// override colour function
	3515	tex->setColourOperationEx(LBX_SOURCE1, LBS_MANUAL, LBS_CURRENT,
	3516	isShadowTechniqueAdditive()? ColourValue::Black : mShadowColour);
	3517
	3518	}
	3519	// Remove any extras
	3520	while (retPass->getNumTextureUnitStates() > origPassTUCount)
	3521	{
	3522	retPass->removeTextureUnitState(origPassTUCount);
	3523	}
	3524
	3525	}
	3526	else
	3527	{
	3528	// reset
	3529	retPass->setSceneBlending(SBT_REPLACE);
	3530	retPass->setAlphaRejectFunction(CMPF_ALWAYS_PASS);
	3531	while (retPass->getNumTextureUnitStates() > 0)
	3532	{
	3533	retPass->removeTextureUnitState(0);
	3534	}
	3535	}
	3536
	3537	// Propagate culling modes
	3538	retPass->setCullingMode(pass->getCullingMode());
	3539	retPass->setManualCullingMode(pass->getManualCullingMode());
	3540
	3541
	3542	if (!pass->getShadowCasterVertexProgramName().empty())
	3543	{
	3544	// Have to merge the shadow caster vertex program in
	3545	retPass->setVertexProgram(
	3546	pass->getShadowCasterVertexProgramName());
	3547	const GpuProgramPtr& prg = retPass->getVertexProgram();
	3548	// Load this program if not done already
	3549	if (!prg->isLoaded())
	3550	prg->load();
	3551	// Copy params
	3552	retPass->setVertexProgramParameters(
	3553	pass->getShadowCasterVertexProgramParameters());
	3554	if (retPass == mShadowTextureCustomCasterPass)
	3555	{
	3556	// mark that we've overridden the standard
	3557	mShadowTextureCasterVPDirty = true;
	3558	}
	3559	// Also have to hack the light autoparams, that is done later
	3560	}
	3561	else
	3562	{
	3563	retPass->setVertexProgram(StringUtil::BLANK);
	3564	if (mShadowTextureCasterVPDirty)
	3565	{
	3566	// reset
	3567	mShadowTextureCustomCasterPass->setVertexProgram(
	3568	mShadowTextureCustomCasterVertexProgram);
	3569	if(mShadowTextureCustomCasterPass->hasVertexProgram())
	3570	{
	3571	mShadowTextureCustomCasterPass->setVertexProgramParameters(
	3572	mShadowTextureCustomCasterVPParams);
	3573
	3574	}
	3575	mShadowTextureCasterVPDirty = false;
	3576	}
	3577	}
	3578	return retPass;
	3579	}
	3580	else
	3581	{
	3582	return pass;
	3583	}
	3584
	3585	}
	3586	//---------------------------------------------------------------------
	3587	const Pass* SceneManager::deriveShadowReceiverPass(const Pass* pass)
	3588	{
	3589
	3590	if (isShadowTechniqueTextureBased())
	3591	{
	3592	Pass* retPass = mShadowTextureCustomReceiverPass ?
	3593	mShadowTextureCustomReceiverPass : mShadowReceiverPass;
	3594
	3595	if (pass->hasVertexProgram())
	3596	{
	3597	// Have to merge the receiver vertex program in
	3598	retPass->setVertexProgram(
	3599	pass->getShadowReceiverVertexProgramName());
	3600	// Did this result in a new vertex program?
	3601	if (retPass->hasVertexProgram())
	3602	{
	3603	const GpuProgramPtr& prg = retPass->getVertexProgram();
	3604	// Load this program if required
	3605	if (!prg->isLoaded())
	3606	prg->load();
	3607	// Copy params
	3608	retPass->setVertexProgramParameters(
	3609	pass->getShadowReceiverVertexProgramParameters());
	3610
	3611	if (retPass == mShadowTextureCustomReceiverPass)
	3612	{
	3613	// mark that we've overridden the standard
	3614	mShadowTextureReceiverVPDirty = true;
	3615	}
	3616	}
	3617	// Also have to hack the light autoparams, that is done later
	3618	}
	3619	else
	3620	{
	3621	retPass->setVertexProgram(StringUtil::BLANK);
	3622	}
	3623
	3624	bool resetFragmentProgram = true;
	3625	size_t keepTUCount;
	3626	// If additive, need lighting parameters & standard programs
	3627	if (isShadowTechniqueAdditive())
	3628	{
	3629	keepTUCount = 1;
	3630	retPass->setLightingEnabled(true);
	3631	retPass->setAmbient(pass->getAmbient());
	3632	retPass->setSelfIllumination(pass->getSelfIllumination());
	3633	retPass->setDiffuse(pass->getDiffuse());
	3634	retPass->setSpecular(pass->getSpecular());
	3635	retPass->setShininess(pass->getShininess());
	3636	retPass->setIteratePerLight(pass->getIteratePerLight(),
	3637	pass->getRunOnlyForOneLightType(), pass->getOnlyLightType());
	3638
	3639	// We need to keep alpha rejection settings
	3640	retPass->setAlphaRejectSettings(pass->getAlphaRejectFunction(),
	3641	pass->getAlphaRejectValue());
	3642	// Copy texture state, shift up one since 0 is shadow texture
	3643	size_t origPassTUCount = pass->getNumTextureUnitStates();
	3644	for (size_t t = 0; t < origPassTUCount; ++t)
	3645	{
	3646	size_t targetIndex = t+1;
	3647	TextureUnitState* tex;
	3648	if (retPass->getNumTextureUnitStates() <= targetIndex)
	3649	{
	3650	tex = retPass->createTextureUnitState();
	3651	}
	3652	else
	3653	{
	3654	tex = retPass->getTextureUnitState(targetIndex);
	3655	}
	3656	(tex) = (pass->getTextureUnitState(t));
	3657	}
	3658	keepTUCount = origPassTUCount + 1;
	3659
	3660	// Will also need fragment programs since this is a complex light setup
	3661	if (pass->hasFragmentProgram())
	3662	{
	3663	String fragName = pass->getShadowReceiverFragmentProgramName();
	3664	GpuProgramParametersSharedPtr params;
	3665	if (!fragName.empty())
	3666	{
	3667	resetFragmentProgram = false;
	3668
	3669	params = pass->getShadowReceiverFragmentProgramParameters();
	3670
	3671	retPass->setFragmentProgram(fragName);
	3672	const GpuProgramPtr& prg = retPass->getFragmentProgram();
	3673	// Load this program if required
	3674	if (!prg->isLoaded())
	3675	prg->load();
	3676	// Copy params
	3677	retPass->setFragmentProgramParameters(params);
	3678
	3679	// Did we bind a shadow vertex program?
	3680	if (pass->hasVertexProgram() && !retPass->hasVertexProgram())
	3681	{
	3682	// We didn't bind a receiver-specific program, so bind the original
	3683	retPass->setVertexProgram(pass->getVertexProgramName());
	3684	const GpuProgramPtr& prg = retPass->getVertexProgram();
	3685	// Load this program if required
	3686	if (!prg->isLoaded())
	3687	prg->load();
	3688	// Copy params
	3689	retPass->setVertexProgramParameters(
	3690	pass->getVertexProgramParameters());
	3691
	3692	if (retPass == mShadowTextureCustomReceiverPass)
	3693	{
	3694	// mark that we've overridden the standard
	3695	mShadowTextureReceiverVPDirty = true;
	3696	}
	3697	}
	3698	} // valid shadow fragment program
	3699	} // ori pass has fragment program
	3700
	3701	}// additive lighting
	3702	else
	3703	{
	3704	// need to keep spotlight fade etc
	3705	keepTUCount = retPass->getNumTextureUnitStates();
	3706	}
	3707
	3708	// reset fragment program
	3709	if (resetFragmentProgram)
	3710	{
	3711	retPass->setFragmentProgram(StringUtil::BLANK);
	3712	}
	3713	// Remove any extra texture units
	3714	while (retPass->getNumTextureUnitStates() > keepTUCount)
	3715	{
	3716	retPass->removeTextureUnitState(keepTUCount);
	3717	}
	3718
	3719	// reset vertex program
	3720	if (retPass->hasVertexProgram() && !pass->hasVertexProgram())
	3721	{
	3722	// reset
	3723	retPass->setVertexProgram("");
	3724
	3725	if (mShadowTextureReceiverVPDirty)
	3726	{
	3727	// reset
	3728	mShadowTextureCustomReceiverPass->setVertexProgram(
	3729	mShadowTextureCustomReceiverVertexProgram);
	3730	if(mShadowTextureCustomReceiverPass->hasVertexProgram())
	3731	{
	3732	mShadowTextureCustomReceiverPass->setVertexProgramParameters(
	3733	mShadowTextureCustomReceiverVPParams);
	3734
	3735	}
	3736	mShadowTextureReceiverVPDirty = false;
	3737	}
	3738	}
	3739
	3740	retPass->_load();
	3741
	3742	return retPass;
	3743	}
	3744	else
	3745	{
	3746	return pass;
	3747	}
	3748
	3749	}
	3750	//---------------------------------------------------------------------
	3751	void SceneManager::renderShadowVolumesToStencil(const Light* light, const Camera* camera)
	3752	{
	3753	// Get the shadow caster list
	3754	const ShadowCasterList& casters = findShadowCastersForLight(light, camera);
	3755	// Check there are some shadow casters to render
	3756	if (casters.empty())
	3757	{
	3758	// No casters, just do nothing
	3759	return;
	3760	}
	3761
	3762	// Set up scissor test (point & spot lights only)
	3763	bool scissored = false;
	3764	if (light->getType() != Light::LT_DIRECTIONAL &&
	3765	mDestRenderSystem->getCapabilities()->hasCapability(RSC_SCISSOR_TEST))
	3766	{
	3767	// Project the sphere onto the camera
	3768	Real left, right, top, bottom;
	3769	Sphere sphere(light->getDerivedPosition(), light->getAttenuationRange());
	3770	if (camera->projectSphere(sphere, &left, &top, &right, &bottom))
	3771	{
	3772	scissored = true;
	3773	// Turn normalised device coordinates into pixels
	3774	int iLeft, iTop, iWidth, iHeight;
	3775	mCurrentViewport->getActualDimensions(iLeft, iTop, iWidth, iHeight);
	3776	size_t szLeft, szRight, szTop, szBottom;
	3777
	3778	szLeft = (size_t)(iLeft + ((left + 1) * 0.5 * iWidth));
	3779	szRight = (size_t)(iLeft + ((right + 1) * 0.5 * iWidth));
	3780	szTop = (size_t)(iTop + ((-top + 1) * 0.5 * iHeight));
	3781	szBottom = (size_t)(iTop + ((-bottom + 1) * 0.5 * iHeight));
	3782
	3783	mDestRenderSystem->setScissorTest(true, szLeft, szTop, szRight, szBottom);
	3784	}
	3785	}
	3786
	3787	mDestRenderSystem->unbindGpuProgram(GPT_FRAGMENT_PROGRAM);
	3788
	3789	// Can we do a 2-sided stencil?
	3790	bool stencil2sided = false;
	3791	if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_TWO_SIDED_STENCIL) &&
	3792	mDestRenderSystem->getCapabilities()->hasCapability(RSC_STENCIL_WRAP))
	3793	{
	3794	// enable
	3795	stencil2sided = true;
	3796	}
	3797
	3798	// Do we have access to vertex programs?
	3799	bool extrudeInSoftware = true;
	3800	bool finiteExtrude = !mShadowUseInfiniteFarPlane \|\|
	3801	!mDestRenderSystem->getCapabilities()->hasCapability(RSC_INFINITE_FAR_PLANE);
	3802	if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_VERTEX_PROGRAM))
	3803	{
	3804	extrudeInSoftware = false;
	3805	// attach the appropriate extrusion vertex program
	3806	// Note we never unset it because support for vertex programs is constant
	3807	mShadowStencilPass->setVertexProgram(
	3808	ShadowVolumeExtrudeProgram::getProgramName(light->getType(), finiteExtrude, false)
	3809	, false);
	3810	// Set params
	3811	if (finiteExtrude)
	3812	{
	3813	mShadowStencilPass->setVertexProgramParameters(mFiniteExtrusionParams);
	3814	}
	3815	else
	3816	{
	3817	mShadowStencilPass->setVertexProgramParameters(mInfiniteExtrusionParams);
	3818	}
	3819	if (mDebugShadows)
	3820	{
	3821	mShadowDebugPass->setVertexProgram(
	3822	ShadowVolumeExtrudeProgram::getProgramName(light->getType(), finiteExtrude, true)
	3823	, false);
	3824	// Set params
	3825	if (finiteExtrude)
	3826	{
	3827	mShadowDebugPass->setVertexProgramParameters(mFiniteExtrusionParams);
	3828	}
	3829	else
	3830	{
	3831	mShadowDebugPass->setVertexProgramParameters(mInfiniteExtrusionParams);
	3832	}
	3833	}
	3834
	3835	mDestRenderSystem->bindGpuProgram(mShadowStencilPass->getVertexProgram()->_getBindingDelegate());
	3836
	3837	}
	3838	else
	3839	{
	3840	mDestRenderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM);
	3841	}
	3842
	3843	// Add light to internal list for use in render call
	3844	LightList lightList;
	3845	// const_cast is forgiveable here since we pass this const
	3846	lightList.push_back(const_cast<Light*>(light));
	3847
	3848	// Turn off colour writing and depth writing
	3849	mDestRenderSystem->_setColourBufferWriteEnabled(false, false, false, false);
	3850	mDestRenderSystem->_disableTextureUnitsFrom(0);
	3851	mDestRenderSystem->_setDepthBufferParams(true, false, CMPF_LESS);
	3852	mDestRenderSystem->setStencilCheckEnabled(true);
	3853
	3854	// Calculate extrusion distance
	3855	// Use direction light extrusion distance now, just form optimize code
	3856	// generate a little, point/spot light will up to date later
	3857	Real extrudeDist = mShadowDirLightExtrudeDist;
	3858
	3859	// Figure out the near clip volume
	3860	const PlaneBoundedVolume& nearClipVol =
	3861	light->_getNearClipVolume(camera);
	3862
	3863	// Now iterate over the casters and render
	3864	ShadowCasterList::const_iterator si, siend;
	3865	siend = casters.end();
	3866
	3867
	3868	// Now iterate over the casters and render
	3869	for (si = casters.begin(); si != siend; ++si)
	3870	{
	3871	ShadowCaster* caster = *si;
	3872	bool zfailAlgo = camera->isCustomNearClipPlaneEnabled();
	3873	unsigned long flags = 0;
	3874
	3875	if (light->getType() != Light::LT_DIRECTIONAL)
	3876	{
	3877	extrudeDist = caster->getPointExtrusionDistance(light);
	3878	}
	3879
	3880	if (!extrudeInSoftware && !finiteExtrude)
	3881	{
	3882	// hardware extrusion, to infinity (and beyond!)
	3883	flags \|= SRF_EXTRUDE_TO_INFINITY;
	3884	}
	3885
	3886	// Determine whether zfail is required
	3887	if (nearClipVol.intersects(caster->getWorldBoundingBox()))
	3888	{
	3889	// We use zfail for this object only because zfail
	3890	// compatible with zpass algorithm
	3891	zfailAlgo = true;
	3892	// We need to include the light and / or dark cap
	3893	// But only if they will be visible
	3894	if(camera->isVisible(caster->getLightCapBounds()))
	3895	{
	3896	flags \|= SRF_INCLUDE_LIGHT_CAP;
	3897	}
	3898	// zfail needs dark cap
	3899	// UNLESS directional lights using hardware extrusion to infinity
	3900	// since that extrudes to a single point
	3901	if(!((flags & SRF_EXTRUDE_TO_INFINITY) &&
	3902	light->getType() == Light::LT_DIRECTIONAL) &&
	3903	camera->isVisible(caster->getDarkCapBounds(*light, extrudeDist)))
	3904	{
	3905	flags \|= SRF_INCLUDE_DARK_CAP;
	3906	}
	3907	}
	3908	else
	3909	{
	3910	// In zpass we need a dark cap if
	3911	// 1: infinite extrusion on point/spotlight sources in modulative shadows
	3912	// mode, since otherwise in areas where there is no depth (skybox)
	3913	// the infinitely projected volume will leave a dark band
	3914	// 2: finite extrusion on any light source since glancing angles
	3915	// can peek through the end and shadow objects behind incorrectly
	3916	if ((flags & SRF_EXTRUDE_TO_INFINITY) &&
	3917	light->getType() != Light::LT_DIRECTIONAL &&
	3918	isShadowTechniqueModulative() &&
	3919	camera->isVisible(caster->getDarkCapBounds(*light, extrudeDist)))
	3920	{
	3921	flags \|= SRF_INCLUDE_DARK_CAP;
	3922	}
	3923	else if (!(flags & SRF_EXTRUDE_TO_INFINITY) &&
	3924	camera->isVisible(caster->getDarkCapBounds(*light, extrudeDist)))
	3925	{
	3926	flags \|= SRF_INCLUDE_DARK_CAP;
	3927	}
	3928
	3929	}
	3930
	3931	// Get shadow renderables
	3932	ShadowCaster::ShadowRenderableListIterator iShadowRenderables =
	3933	caster->getShadowVolumeRenderableIterator(mShadowTechnique,
	3934	light, &mShadowIndexBuffer, extrudeInSoftware,
	3935	extrudeDist, flags);
	3936
	3937	// Render a shadow volume here
	3938	// - if we have 2-sided stencil, one render with no culling
	3939	// - otherwise, 2 renders, one with each culling method and invert the ops
	3940	setShadowVolumeStencilState(false, zfailAlgo, stencil2sided);
	3941	renderShadowVolumeObjects(iShadowRenderables, mShadowStencilPass, &lightList, flags,
	3942	false, zfailAlgo, stencil2sided);
	3943	if (!stencil2sided)
	3944	{
	3945	// Second pass
	3946	setShadowVolumeStencilState(true, zfailAlgo, false);
	3947	renderShadowVolumeObjects(iShadowRenderables, mShadowStencilPass, &lightList, flags,
	3948	true, zfailAlgo, false);
	3949	}
	3950
	3951	// Do we need to render a debug shadow marker?
	3952	if (mDebugShadows)
	3953	{
	3954	// reset stencil & colour ops
	3955	mDestRenderSystem->setStencilBufferParams();
	3956	mShadowDebugPass->getTextureUnitState(0)->
	3957	setColourOperationEx(LBX_MODULATE, LBS_MANUAL, LBS_CURRENT,
	3958	zfailAlgo ? ColourValue(0.7, 0.0, 0.2) : ColourValue(0.0, 0.7, 0.2));
	3959	_setPass(mShadowDebugPass);
	3960	renderShadowVolumeObjects(iShadowRenderables, mShadowDebugPass, &lightList, flags,
	3961	true, false, false);
	3962	mDestRenderSystem->_setColourBufferWriteEnabled(false, false, false, false);
	3963	mDestRenderSystem->_setDepthBufferFunction(CMPF_LESS);
	3964	}
	3965	}
	3966
	3967	// revert colour write state
	3968	mDestRenderSystem->_setColourBufferWriteEnabled(true, true, true, true);
	3969	// revert depth state
	3970	mDestRenderSystem->_setDepthBufferParams();
	3971
	3972	mDestRenderSystem->setStencilCheckEnabled(false);
	3973
	3974	mDestRenderSystem->unbindGpuProgram(GPT_VERTEX_PROGRAM);
	3975
	3976	if (scissored)
	3977	{
	3978	// disable scissor test
	3979	mDestRenderSystem->setScissorTest(false);
	3980	}
	3981
	3982	}
	3983	//---------------------------------------------------------------------
	3984	void SceneManager::renderShadowVolumeObjects(ShadowCaster::ShadowRenderableListIterator iShadowRenderables,
	3985	Pass* pass,
	3986	const LightList *manualLightList,
	3987	unsigned long flags,
	3988	bool secondpass, bool zfail, bool twosided)
	3989	{
	3990	// ----- SHADOW VOLUME LOOP -----
	3991	// Render all shadow renderables with same stencil operations
	3992	while (iShadowRenderables.hasMoreElements())
	3993	{
	3994	ShadowRenderable* sr = iShadowRenderables.getNext();
	3995
	3996	// omit hidden renderables
	3997	if (sr->isVisible())
	3998	{
	3999	// render volume, including dark and (maybe) light caps
	4000	renderSingleObject(sr, pass, false, manualLightList);
	4001
	4002	// optionally render separate light cap
	4003	if (sr->isLightCapSeparate() && (flags & SRF_INCLUDE_LIGHT_CAP))
	4004	{
	4005	ShadowRenderable* lightCap = sr->getLightCapRenderable();
	4006	assert(lightCap && "Shadow renderable is missing a separate light cap renderable!");
	4007
	4008	// We must take care with light caps when we could 'see' the back facing
	4009	// triangles directly:
	4010	// 1. The front facing light caps must render as always fail depth
	4011	// check to avoid 'depth fighting'.
	4012	// 2. The back facing light caps must use normal depth function to
	4013	// avoid break the standard depth check
	4014	//
	4015	// TODO:
	4016	// 1. Separate light caps rendering doesn't need for the 'closed'
	4017	// mesh that never touch the near plane, because in this instance,
	4018	// we couldn't 'see' any back facing triangles directly. The
	4019	// 'closed' mesh must determinate by edge list builder.
	4020	// 2. There still exists 'depth fighting' bug with coplane triangles
	4021	// that has opposite facing. This usually occur when use two side
	4022	// material in the modeling tools and the model exporting tools
	4023	// exporting double triangles to represent this model. This bug
	4024	// can't fixed in GPU only, there must has extra work on edge list
	4025	// builder and shadow volume generater to fix it.
	4026	//
	4027	if (twosided)
	4028	{
	4029	// select back facing light caps to render
	4030	mDestRenderSystem->_setCullingMode(CULL_ANTICLOCKWISE);
	4031	// use normal depth function for back facing light caps
	4032	renderSingleObject(lightCap, pass, false, manualLightList);
	4033
	4034	// select front facing light caps to render
	4035	mDestRenderSystem->_setCullingMode(CULL_CLOCKWISE);
	4036	// must always fail depth check for front facing light caps
	4037	mDestRenderSystem->_setDepthBufferFunction(CMPF_ALWAYS_FAIL);
	4038	renderSingleObject(lightCap, pass, false, manualLightList);
	4039
	4040	// reset depth function
	4041	mDestRenderSystem->_setDepthBufferFunction(CMPF_LESS);
	4042	// reset culling mode
	4043	mDestRenderSystem->_setCullingMode(CULL_NONE);
	4044	}
	4045	else if ((secondpass \|\| zfail) && !(secondpass && zfail))
	4046	{
	4047	// use normal depth function for back facing light caps
	4048	renderSingleObject(lightCap, pass, false, manualLightList);
	4049	}
	4050	else
	4051	{
	4052	// must always fail depth check for front facing light caps
	4053	mDestRenderSystem->_setDepthBufferFunction(CMPF_ALWAYS_FAIL);
	4054	renderSingleObject(lightCap, pass, false, manualLightList);
	4055
	4056	// reset depth function
	4057	mDestRenderSystem->_setDepthBufferFunction(CMPF_LESS);
	4058	}
	4059	}
	4060	}
	4061	}
	4062	}
	4063	//---------------------------------------------------------------------
	4064	void SceneManager::setShadowVolumeStencilState(bool secondpass, bool zfail, bool twosided)
	4065	{
	4066	// Determinate the best stencil operation
	4067	StencilOperation incrOp, decrOp;
	4068	if (mDestRenderSystem->getCapabilities()->hasCapability(RSC_STENCIL_WRAP))
	4069	{
	4070	incrOp = SOP_INCREMENT_WRAP;
	4071	decrOp = SOP_DECREMENT_WRAP;
	4072	}
	4073	else
	4074	{
	4075	incrOp = SOP_INCREMENT;
	4076	decrOp = SOP_DECREMENT;
	4077	}
	4078
	4079	// First pass, do front faces if zpass
	4080	// Second pass, do back faces if zpass
	4081	// Invert if zfail
	4082	// this is to ensure we always increment before decrement
	4083	// When two-sided stencil, always pass front face stencil
	4084	// operation parameters and the inverse of them will happen
	4085	// for back faces
	4086	if ( !twosided && ((secondpass \|\| zfail) && !(secondpass && zfail)) )
	4087	{
	4088	mDestRenderSystem->_setCullingMode(
	4089	twosided? CULL_NONE : CULL_ANTICLOCKWISE);
	4090	mDestRenderSystem->setStencilBufferParams(
	4091	CMPF_ALWAYS_PASS, // always pass stencil check
	4092	0, // no ref value (no compare)
	4093	0xFFFFFFFF, // no mask
	4094	SOP_KEEP, // stencil test will never fail
	4095	zfail ? incrOp : SOP_KEEP, // back face depth fail
	4096	zfail ? SOP_KEEP : decrOp, // back face pass
	4097	twosided
	4098	);
	4099	}
	4100	else
	4101	{
	4102	mDestRenderSystem->_setCullingMode(
	4103	twosided? CULL_NONE : CULL_CLOCKWISE);
	4104	mDestRenderSystem->setStencilBufferParams(
	4105	CMPF_ALWAYS_PASS, // always pass stencil check
	4106	0, // no ref value (no compare)
	4107	0xFFFFFFFF, // no mask
	4108	SOP_KEEP, // stencil test will never fail
	4109	zfail ? decrOp : SOP_KEEP, // front face depth fail
	4110	zfail ? SOP_KEEP : incrOp, // front face pass
	4111	twosided
	4112	);
	4113	}
	4114	}
	4115	//---------------------------------------------------------------------
	4116	void SceneManager::setShadowColour(const ColourValue& colour)
	4117	{
	4118	mShadowColour = colour;
	4119
	4120	// Change shadow material setting only when it's prepared,
	4121	// otherwise, it'll set up while preparing shadow materials.
	4122	if (mShadowModulativePass)
	4123	{
	4124	mShadowModulativePass->getTextureUnitState(0)->setColourOperationEx(
	4125	LBX_MODULATE, LBS_MANUAL, LBS_CURRENT, colour);
	4126	}
	4127	}
	4128	//---------------------------------------------------------------------
	4129	const ColourValue& SceneManager::getShadowColour(void) const
	4130	{
	4131	return mShadowColour;
	4132	}
	4133	//---------------------------------------------------------------------
	4134	void SceneManager::setShadowFarDistance(Real distance)
	4135	{
	4136	mShadowFarDist = distance;
	4137	mShadowFarDistSquared = distance * distance;
	4138	}
	4139	//---------------------------------------------------------------------
	4140	void SceneManager::setShadowDirectionalLightExtrusionDistance(Real dist)
	4141	{
	4142	mShadowDirLightExtrudeDist = dist;
	4143	}
	4144	//---------------------------------------------------------------------
	4145	Real SceneManager::getShadowDirectionalLightExtrusionDistance(void) const
	4146	{
	4147	return mShadowDirLightExtrudeDist;
	4148	}
	4149	//---------------------------------------------------------------------
	4150	void SceneManager::setShadowIndexBufferSize(size_t size)
	4151	{
	4152	if (!mShadowIndexBuffer.isNull() && size != mShadowIndexBufferSize)
	4153	{
	4154	// re-create shadow buffer with new size
	4155	mShadowIndexBuffer = HardwareBufferManager::getSingleton().
	4156	createIndexBuffer(HardwareIndexBuffer::IT_16BIT,
	4157	mShadowIndexBufferSize,
	4158	HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE,
	4159	false);
	4160	}
	4161	mShadowIndexBufferSize = size;
	4162	}
	4163	//---------------------------------------------------------------------
	4164	void SceneManager::setShadowTextureSize(unsigned short size)
	4165	{
	4166	// possibly recreate
	4167	createShadowTextures(size, mShadowTextureCount, mShadowTextureFormat);
	4168	mShadowTextureSize = size;
	4169	}
	4170	//---------------------------------------------------------------------
	4171	void SceneManager::setShadowTextureCount(unsigned short count)
	4172	{
	4173	// possibly recreate
	4174	createShadowTextures(mShadowTextureSize, count, mShadowTextureFormat);
	4175	mShadowTextureCount = count;
	4176	}
	4177	//---------------------------------------------------------------------
	4178	void SceneManager::setShadowTexturePixelFormat(PixelFormat fmt)
	4179	{
	4180	// possibly recreate
	4181	createShadowTextures(mShadowTextureSize, mShadowTextureCount, fmt);
	4182	mShadowTextureFormat = fmt;
	4183	}
	4184	//---------------------------------------------------------------------
	4185	void SceneManager::setShadowTextureSettings(unsigned short size,
	4186	unsigned short count, PixelFormat fmt)
	4187	{
	4188	if (!mShadowTextures.empty() &&
	4189	(count != mShadowTextureCount \|\|
	4190	size != mShadowTextureSize \|\|
	4191	fmt != mShadowTextureFormat))
	4192	{
	4193	// recreate
	4194	createShadowTextures(size, count, fmt);
	4195	}
	4196	mShadowTextureCount = count;
	4197	mShadowTextureSize = size;
	4198	mShadowTextureFormat = fmt;
	4199	}
	4200	//---------------------------------------------------------------------
	4201	void SceneManager::setShadowTextureSelfShadow(bool selfShadow)
	4202	{
	4203	mShadowTextureSelfShadow = selfShadow;
	4204	if (isShadowTechniqueTextureBased())
	4205	getRenderQueue()->setShadowCastersCannotBeReceivers(!selfShadow);
	4206	}
	4207	//---------------------------------------------------------------------
	4208	void SceneManager::setShadowTextureCasterMaterial(const String& name)
	4209	{
	4210	if (name.empty())
	4211	{
	4212	mShadowTextureCustomCasterPass = 0;
	4213	}
	4214	else
	4215	{
	4216	MaterialPtr mat = MaterialManager::getSingleton().getByName(name);
	4217	if (mat.isNull())
	4218	{
	4219	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	4220	"Cannot locate material called '" + name + "'",
	4221	"SceneManager::setShadowTextureCasterMaterial");
	4222	}
	4223	mat->load();
	4224	mShadowTextureCustomCasterPass = mat->getBestTechnique()->getPass(0);
	4225	if (mShadowTextureCustomCasterPass->hasVertexProgram())
	4226	{
	4227	// Save vertex program and params in case we have to swap them out
	4228	mShadowTextureCustomCasterVertexProgram =
	4229	mShadowTextureCustomCasterPass->getVertexProgramName();
	4230	mShadowTextureCustomCasterVPParams =
	4231	mShadowTextureCustomCasterPass->getVertexProgramParameters();
	4232	mShadowTextureCasterVPDirty = false;
	4233
	4234	}
	4235	}
	4236	}
	4237	//---------------------------------------------------------------------
	4238	void SceneManager::setShadowTextureReceiverMaterial(const String& name)
	4239	{
	4240	if (name.empty())
	4241	{
	4242	mShadowTextureCustomReceiverPass = 0;
	4243	}
	4244	else
	4245	{
	4246	MaterialPtr mat = MaterialManager::getSingleton().getByName(name);
	4247	if (mat.isNull())
	4248	{
	4249	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	4250	"Cannot locate material called '" + name + "'",
	4251	"SceneManager::setShadowTextureReceiverMaterial");
	4252	}
	4253	mat->load();
	4254	mShadowTextureCustomReceiverPass = mat->getBestTechnique()->getPass(0);
	4255	if (mShadowTextureCustomReceiverPass->hasVertexProgram())
	4256	{
	4257	// Save vertex program and params in case we have to swap them out
	4258	mShadowTextureCustomReceiverVertexProgram =
	4259	mShadowTextureCustomReceiverPass->getVertexProgramName();
	4260	mShadowTextureCustomReceiverVPParams =
	4261	mShadowTextureCustomReceiverPass->getVertexProgramParameters();
	4262	mShadowTextureReceiverVPDirty = false;
	4263
	4264	}
	4265	}
	4266	}
	4267	//---------------------------------------------------------------------
	4268	void SceneManager::createShadowTextures(unsigned short size,
	4269	unsigned short count, PixelFormat fmt)
	4270	{
	4271	static const String baseName = "Ogre/ShadowTexture";
	4272
	4273	if (!isShadowTechniqueTextureBased() \|\|
	4274	!mShadowTextures.empty() &&
	4275	count == mShadowTextureCount &&
	4276	size == mShadowTextureSize &&
	4277	fmt == mShadowTextureFormat)
	4278	{
	4279	// no change
	4280	return;
	4281	}
	4282
	4283
	4284	// destroy existing
	4285	destroyShadowTextures();
	4286
	4287	// Recreate shadow textures
	4288	for (unsigned short t = 0; t < count; ++t)
	4289	{
	4290	String targName = baseName + StringConverter::toString(t);
	4291	String camName = baseName + "Cam" + StringConverter::toString(t);
	4292	String matName = baseName + "Mat" + StringConverter::toString(t);
	4293
	4294	// try to get existing texture first, since we share these between
	4295	// potentially multiple SMs
	4296	TexturePtr shadowTex = TextureManager::getSingleton().getByName(targName);
	4297	if (shadowTex.isNull())
	4298	{
	4299	shadowTex = TextureManager::getSingleton().createManual(
	4300	targName,
	4301	ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME,
	4302	TEX_TYPE_2D, size, size, 0, mShadowTextureFormat,
	4303	TU_RENDERTARGET);
	4304	}
	4305	else if (shadowTex->getWidth() != size
	4306	\|\| shadowTex->getHeight() != size
	4307	\|\| shadowTex->getFormat() != mShadowTextureFormat)
	4308	{
	4309	StringUtil::StrStreamType s;
	4310	s << "Warning: shadow texture #" << t << " is shared "
	4311	<< "between scene managers but the sizes / formats "
	4312	<< "do not agree. Consider rationalising your scene manager "
	4313	<< "shadow texture settings.";
	4314	LogManager::getSingleton().logMessage(s.str());
	4315	}
	4316
	4317	// Ensure texture loaded
	4318	shadowTex->load();
	4319
	4320	RenderTexture *shadowRTT = shadowTex->getBuffer()->getRenderTarget();
	4321
	4322	// Create camera for this texture, but note that we have to rebind
	4323	// in prepareShadowTextures to coexist with multiple SMs
	4324	Camera* cam = createCamera(camName);
	4325	cam->setAspectRatio(1.0f);
	4326	// Don't use rendering distance for light cameras; we don't want shadows
	4327	// for visible objects disappearing, especially for directional lights
	4328	cam->setUseRenderingDistance(false);
	4329	mShadowTextureCameras.push_back(cam);
	4330
	4331	// Create a viewport, if not there already
	4332	if (shadowRTT->getNumViewports() == 0)
	4333	{
	4334	// Note camera assignment is transient when multiple SMs
	4335	Viewport *v = shadowRTT->addViewport(cam);
	4336	v->setClearEveryFrame(true);
	4337	// remove overlays
	4338	v->setOverlaysEnabled(false);
	4339	}
	4340
	4341	// Don't update automatically - we'll do it when required
	4342	shadowRTT->setAutoUpdated(false);
	4343
	4344	mShadowTextures.push_back(shadowTex);
	4345
	4346
	4347	// Also create corresponding Material used for rendering this shadow
	4348	MaterialPtr mat = MaterialManager::getSingleton().getByName(matName);
	4349	if (mat.isNull())
	4350	{
	4351	mat = MaterialManager::getSingleton().create(
	4352	matName, ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
	4353	}
	4354	else
	4355	{
	4356	mat->getTechnique(0)->getPass(0)->removeAllTextureUnitStates();
	4357	}
	4358	// create texture unit referring to render target texture
	4359	TextureUnitState* texUnit =
	4360	mat->getTechnique(0)->getPass(0)->createTextureUnitState(targName);
	4361	// set projective based on camera
	4362	texUnit->setProjectiveTexturing(true, cam);
	4363	texUnit->setTextureAddressingMode(TextureUnitState::TAM_CLAMP);
	4364	mat->touch();
	4365
	4366	}
	4367	}
	4368	//---------------------------------------------------------------------
	4369	void SceneManager::destroyShadowTextures(void)
	4370	{
	4371	ShadowTextureList::iterator i, iend;
	4372	ShadowTextureCameraList::iterator ci;
	4373	iend = mShadowTextures.end();
	4374	ci = mShadowTextureCameras.begin();
	4375	for (i = mShadowTextures.begin(); i != iend; ++i, ++ci)
	4376	{
	4377	TexturePtr &shadowTex = *i;
	4378	// If the reference count on this texture is 1 over the resource system
	4379	// overhead, then we can remove the texture
	4380	if (shadowTex.useCount() ==
	4381	ResourceGroupManager::RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS + 1)
	4382	{
	4383	// destroy texture
	4384	TextureManager::getSingleton().remove(shadowTex->getName());
	4385	}
	4386
	4387	// Always destroy camera since they are local to this SM
	4388	destroyCamera(*ci);
	4389	}
	4390	mShadowTextures.clear();
	4391	mShadowTextureCameras.clear();
	4392
	4393
	4394	}
	4395	//---------------------------------------------------------------------
	4396	void SceneManager::prepareShadowTextures(Camera* cam, Viewport* vp)
	4397	{
	4398	// Set the illumination stage, prevents recursive calls
	4399	IlluminationRenderStage savedStage = mIlluminationStage;
	4400	mIlluminationStage = IRS_RENDER_TO_TEXTURE;
	4401
	4402	// Determine far shadow distance
	4403	Real shadowDist = mShadowFarDist;
	4404	if (!shadowDist)
	4405	{
	4406	// need a shadow distance, make one up
	4407	shadowDist = cam->getNearClipDistance() * 300;
	4408	}
	4409	Real shadowOffset = shadowDist * mShadowTextureOffset;
	4410	// Precalculate fading info
	4411	Real shadowEnd = shadowDist + shadowOffset;
	4412	Real fadeStart = shadowEnd * mShadowTextureFadeStart;
	4413	Real fadeEnd = shadowEnd * mShadowTextureFadeEnd;
	4414	// set fogging to hide the shadow edge
	4415	// Additive lighting needs fading too (directional)
	4416	mShadowReceiverPass->setFog(true, FOG_LINEAR, ColourValue::White,
	4417	0, fadeStart, fadeEnd);
	4418
	4419	// Iterate over the lights we've found, max out at the limit of light textures
	4420
	4421	LightList::iterator i, iend;
	4422	ShadowTextureList::iterator si, siend;
	4423	ShadowTextureCameraList::iterator ci;
	4424	iend = mLightsAffectingFrustum.end();
	4425	siend = mShadowTextures.end();
	4426	ci = mShadowTextureCameras.begin();
	4427	for (i = mLightsAffectingFrustum.begin(), si = mShadowTextures.begin();
	4428	i != iend && si != siend; ++i)
	4429	{
	4430	Light* light = *i;
	4431
	4432	// Skip non-shadowing lights
	4433	if (!light->getCastShadows())
	4434	continue;
	4435
	4436	TexturePtr &shadowTex = *si;
	4437	RenderTarget *shadowRTT = shadowTex->getBuffer()->getRenderTarget();
	4438	Viewport *shadowView = shadowRTT->getViewport(0);
	4439	Camera texCam = ci;
	4440	// rebind camera, incase another SM in use which has switched to its cam
	4441	shadowView->setCamera(texCam);
	4442
	4443	Vector3 pos, dir;
	4444
	4445	// Directional lights
	4446	if (light->getType() == Light::LT_DIRECTIONAL)
	4447	{
	4448	// set up the shadow texture
	4449	// Set ortho projection
	4450	texCam->setProjectionType(PT_ORTHOGRAPHIC);
	4451	// set easy FOV and near dist so that texture covers far dist
	4452	texCam->setFOVy(Degree(90));
	4453	texCam->setNearClipDistance(shadowDist);
	4454
	4455	// Calculate look at position
	4456	// We want to look at a spot shadowOffset away from near plane
	4457	// 0.5 is a litle too close for angles
	4458	Vector3 target = cam->getDerivedPosition() +
	4459	(cam->getDerivedDirection() * shadowOffset);
	4460
	4461	// Calculate direction, which same as directional light direction
	4462	dir = - light->getDerivedDirection(); // backwards since point down -z
	4463	dir.normalise();
	4464
	4465	// Calculate position
	4466	// We want to be in the -ve direction of the light direction
	4467	// far enough to project for the dir light extrusion distance
	4468	pos = target + dir * mShadowDirLightExtrudeDist;
	4469
	4470	// Round local x/y position based on a world-space texel; this helps to reduce
	4471	// jittering caused by the projection moving with the camera
	4472	// Viewport is 2 * near clip distance across (90 degree fov)
	4473	Real worldTexelSize = (texCam->getNearClipDistance() * 20) / mShadowTextureSize;
	4474	pos.x -= fmod(pos.x, worldTexelSize);
	4475	pos.y -= fmod(pos.y, worldTexelSize);
	4476	pos.z -= fmod(pos.z, worldTexelSize);
	4477	}
	4478	// Spotlight
	4479	else if (light->getType() == Light::LT_SPOTLIGHT)
	4480	{
	4481	// Set perspective projection
	4482	texCam->setProjectionType(PT_PERSPECTIVE);
	4483	// set FOV slightly larger than the spotlight range to ensure coverage
	4484	texCam->setFOVy(light->getSpotlightOuterAngle()*1.2);
	4485	// set near clip the same as main camera, since they are likely
	4486	// to both reflect the nature of the scene
	4487	texCam->setNearClipDistance(cam->getNearClipDistance());
	4488
	4489	// Calculate position, which same as spotlight position
	4490	pos = light->getDerivedPosition();
	4491
	4492	// Calculate direction, which same as spotlight direction
	4493	dir = - light->getDerivedDirection(); // backwards since point down -z
	4494	dir.normalise();
	4495	}
	4496	// Point light
	4497	else
	4498	{
	4499	// Set perspective projection
	4500	texCam->setProjectionType(PT_PERSPECTIVE);
	4501	// Use 120 degree FOV for point light to ensure coverage more area
	4502	texCam->setFOVy(Degree(120));
	4503	// set near clip the same as main camera, since they are likely
	4504	// to both reflect the nature of the scene
	4505	texCam->setNearClipDistance(cam->getNearClipDistance());
	4506
	4507	// Calculate look at position
	4508	// We want to look at a spot shadowOffset away from near plane
	4509	// 0.5 is a litle too close for angles
	4510	Vector3 target = cam->getDerivedPosition() +
	4511	(cam->getDerivedDirection() * shadowOffset);
	4512
	4513	// Calculate position, which same as point light position
	4514	pos = light->getDerivedPosition();
	4515
	4516	dir = (pos - target); // backwards since point down -z
	4517	dir.normalise();
	4518	}
	4519
	4520	// Finally set position
	4521	texCam->setPosition(pos);
	4522
	4523	// Calculate orientation based on direction calculated above
	4524	/*
	4525	// Next section (camera oriented shadow map) abandoned
	4526	// Always point in the same direction, if we don't do this then
	4527	// we get 'shadow swimming' as camera rotates
	4528	// As it is, we get swimming on moving but this is less noticeable
	4529
	4530	// calculate up vector, we want it aligned with cam direction
	4531	Vector3 up = cam->getDerivedDirection();
	4532	// Check it's not coincident with dir
	4533	if (up.dotProduct(dir) >= 1.0f)
	4534	{
	4535	// Use camera up
	4536	up = cam->getUp();
	4537	}
	4538	*/
	4539	Vector3 up = Vector3::UNIT_Y;
	4540	// Check it's not coincident with dir
	4541	if (Math::Abs(up.dotProduct(dir)) >= 1.0f)
	4542	{
	4543	// Use camera up
	4544	up = Vector3::UNIT_Z;
	4545	}
	4546	// cross twice to rederive, only direction is unaltered
	4547	Vector3 left = dir.crossProduct(up);
	4548	left.normalise();
	4549	up = dir.crossProduct(left);
	4550	up.normalise();
	4551	// Derive quaternion from axes
	4552	Quaternion q;
	4553	q.FromAxes(left, up, dir);
	4554	texCam->setOrientation(q);
	4555
	4556	// Setup background colour
	4557	shadowView->setBackgroundColour(ColourValue::White);
	4558
	4559	// Fire shadow caster update, callee can alter camera settings
	4560	fireShadowTexturesPreCaster(light, texCam);
	4561
	4562	// Update target
	4563	shadowRTT->update();
	4564
	4565	++si; // next shadow texture
	4566	++ci; // next camera
	4567	}
	4568	// Set the illumination stage, prevents recursive calls
	4569	mIlluminationStage = savedStage;
	4570
	4571	fireShadowTexturesUpdated(
	4572	std::min(mLightsAffectingFrustum.size(), mShadowTextures.size()));
	4573	}
	4574	//---------------------------------------------------------------------
	4575	StaticGeometry* SceneManager::createStaticGeometry(const String& name)
	4576	{
	4577	// Check not existing
	4578	if (mStaticGeometryList.find(name) != mStaticGeometryList.end())
	4579	{
	4580	OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
	4581	"StaticGeometry with name '" + name + "' already exists!",
	4582	"SceneManager::createStaticGeometry");
	4583	}
	4584	StaticGeometry* ret = new StaticGeometry(this, name);
	4585	mStaticGeometryList[name] = ret;
	4586	return ret;
	4587	}
	4588	//---------------------------------------------------------------------
	4589	StaticGeometry* SceneManager::getStaticGeometry(const String& name) const
	4590	{
	4591	StaticGeometryList::const_iterator i = mStaticGeometryList.find(name);
	4592	if (i == mStaticGeometryList.end())
	4593	{
	4594	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	4595	"StaticGeometry with name '" + name + "' not found",
	4596	"SceneManager::createStaticGeometry");
	4597	}
	4598	return i->second;
	4599	}
	4600	//---------------------------------------------------------------------
	4601	void SceneManager::destroyStaticGeometry(StaticGeometry* geom)
	4602	{
	4603	destroyStaticGeometry(geom->getName());
	4604	}
	4605	//---------------------------------------------------------------------
	4606	void SceneManager::destroyStaticGeometry(const String& name)
	4607	{
	4608	StaticGeometryList::iterator i = mStaticGeometryList.find(name);
	4609	if (i != mStaticGeometryList.end())
	4610	{
	4611	delete i->second;
	4612	mStaticGeometryList.erase(i);
	4613	}
	4614
	4615	}
	4616	//---------------------------------------------------------------------
	4617	void SceneManager::destroyAllStaticGeometry(void)
	4618	{
	4619	StaticGeometryList::iterator i, iend;
	4620	iend = mStaticGeometryList.end();
	4621	for (i = mStaticGeometryList.begin(); i != iend; ++i)
	4622	{
	4623	delete i->second;
	4624	}
	4625	mStaticGeometryList.clear();
	4626	}
	4627	//---------------------------------------------------------------------
	4628	AxisAlignedBoxSceneQuery*
	4629	SceneManager::createAABBQuery(const AxisAlignedBox& box, unsigned long mask)
	4630	{
	4631	DefaultAxisAlignedBoxSceneQuery* q = new DefaultAxisAlignedBoxSceneQuery(this);
	4632	q->setBox(box);
	4633	q->setQueryMask(mask);
	4634	return q;
	4635	}
	4636	//---------------------------------------------------------------------
	4637	SphereSceneQuery*
	4638	SceneManager::createSphereQuery(const Sphere& sphere, unsigned long mask)
	4639	{
	4640	DefaultSphereSceneQuery* q = new DefaultSphereSceneQuery(this);
	4641	q->setSphere(sphere);
	4642	q->setQueryMask(mask);
	4643	return q;
	4644	}
	4645	//---------------------------------------------------------------------
	4646	PlaneBoundedVolumeListSceneQuery*
	4647	SceneManager::createPlaneBoundedVolumeQuery(const PlaneBoundedVolumeList& volumes,
	4648	unsigned long mask)
	4649	{
	4650	DefaultPlaneBoundedVolumeListSceneQuery* q = new DefaultPlaneBoundedVolumeListSceneQuery(this);
	4651	q->setVolumes(volumes);
	4652	q->setQueryMask(mask);
	4653	return q;
	4654	}
	4655
	4656	//---------------------------------------------------------------------
	4657	RaySceneQuery*
	4658	SceneManager::createRayQuery(const Ray& ray, unsigned long mask)
	4659	{
	4660	DefaultRaySceneQuery* q = new DefaultRaySceneQuery(this);
	4661	q->setRay(ray);
	4662	q->setQueryMask(mask);
	4663	return q;
	4664	}
	4665	//---------------------------------------------------------------------
	4666	IntersectionSceneQuery*
	4667	SceneManager::createIntersectionQuery(unsigned long mask)
	4668	{
	4669
	4670	DefaultIntersectionSceneQuery* q = new DefaultIntersectionSceneQuery(this);
	4671	q->setQueryMask(mask);
	4672	return q;
	4673	}
	4674	//---------------------------------------------------------------------
	4675	void SceneManager::destroyQuery(SceneQuery* query)
	4676	{
	4677	delete query;
	4678	}
	4679	//---------------------------------------------------------------------
	4680	SceneManager::MovableObjectMap*
	4681	SceneManager::getMovableObjectMap(const String& typeName)
	4682	{
	4683	MovableObjectCollectionMap::iterator i =
	4684	mMovableObjectCollectionMap.find(typeName);
	4685	if (i == mMovableObjectCollectionMap.end())
	4686	{
	4687	// create
	4688	MovableObjectMap* newMap = new MovableObjectMap();
	4689	mMovableObjectCollectionMap[typeName] = newMap;
	4690	return newMap;
	4691	}
	4692	else
	4693	{
	4694	return i->second;
	4695	}
	4696	}
	4697	//---------------------------------------------------------------------
	4698	MovableObject* SceneManager::createMovableObject(const String& name,
	4699	const String& typeName, const NameValuePairList* params)
	4700	{
	4701	MovableObjectFactory* factory =
	4702	Root::getSingleton().getMovableObjectFactory(typeName);
	4703	// Check for duplicate names
	4704	MovableObjectMap* objectMap = getMovableObjectMap(typeName);
	4705
	4706	if (objectMap->find(name) != objectMap->end())
	4707	{
	4708	OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
	4709	"An object of type '" + typeName + "' with name '" + name
	4710	+ "' already exists.",
	4711	"SceneManager::createMovableObject");
	4712	}
	4713
	4714	MovableObject* newObj = factory->createInstance(name, this, params);
	4715	(*objectMap)[name] = newObj;
	4716
	4717	return newObj;
	4718
	4719	}
	4720	//---------------------------------------------------------------------
	4721	void SceneManager::destroyMovableObject(const String& name, const String& typeName)
	4722	{
	4723	MovableObjectMap* objectMap = getMovableObjectMap(typeName);
	4724	MovableObjectFactory* factory =
	4725	Root::getSingleton().getMovableObjectFactory(typeName);
	4726
	4727	MovableObjectMap::iterator mi = objectMap->find(name);
	4728	if (mi != objectMap->end())
	4729	{
	4730	factory->destroyInstance(mi->second);
	4731	objectMap->erase(mi);
	4732	}
	4733
	4734	}
	4735	//---------------------------------------------------------------------
	4736	void SceneManager::destroyAllMovableObjectsByType(const String& typeName)
	4737	{
	4738	MovableObjectMap* objectMap = getMovableObjectMap(typeName);
	4739	MovableObjectFactory* factory =
	4740	Root::getSingleton().getMovableObjectFactory(typeName);
	4741	MovableObjectMap::iterator i = objectMap->begin();
	4742	for (; i != objectMap->end(); ++i)
	4743	{
	4744	// Only destroy our own
	4745	if (i->second->_getManager() == this)
	4746	{
	4747	factory->destroyInstance(i->second);
	4748	}
	4749	}
	4750	objectMap->clear();
	4751
	4752	}
	4753	//---------------------------------------------------------------------
	4754	void SceneManager::destroyAllMovableObjects(void)
	4755	{
	4756	MovableObjectCollectionMap::iterator ci = mMovableObjectCollectionMap.begin();
	4757
	4758	for(;ci != mMovableObjectCollectionMap.end(); ++ci)
	4759	{
	4760	if (Root::getSingleton().hasMovableObjectFactory(ci->first))
	4761	{
	4762	// Only destroy if we have a factory instance; otherwise must be injected
	4763	MovableObjectFactory* factory =
	4764	Root::getSingleton().getMovableObjectFactory(ci->first);
	4765	MovableObjectMap::iterator i = ci->second->begin();
	4766	for (; i != ci->second->end(); ++i)
	4767	{
	4768	if (i->second->_getManager() == this)
	4769	{
	4770	factory->destroyInstance(i->second);
	4771	}
	4772	}
	4773	}
	4774	ci->second->clear();
	4775	}
	4776
	4777	}
	4778	//---------------------------------------------------------------------
	4779	MovableObject* SceneManager::getMovableObject(const String& name, const String& typeName)
	4780	{
	4781
	4782	MovableObjectMap* objectMap = getMovableObjectMap(typeName);
	4783	MovableObjectMap::iterator mi = objectMap->find(name);
	4784	if (mi == objectMap->end())
	4785	{
	4786	OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
	4787	"Object named '" + name + "' does not exist.",
	4788	"SceneManager::getMovableObject");
	4789	}
	4790	return mi->second;
	4791
	4792	}
	4793	//---------------------------------------------------------------------
	4794	SceneManager::MovableObjectIterator
	4795	SceneManager::getMovableObjectIterator(const String& typeName)
	4796	{
	4797	MovableObjectMap* objectMap = getMovableObjectMap(typeName);
	4798
	4799	return MovableObjectIterator(objectMap->begin(), objectMap->end());
	4800	}
	4801	//---------------------------------------------------------------------
	4802	void SceneManager::destroyMovableObject(MovableObject* m)
	4803	{
	4804	destroyMovableObject(m->getName(), m->getMovableType());
	4805	}
	4806	//---------------------------------------------------------------------
	4807	void SceneManager::injectMovableObject(MovableObject* m)
	4808	{
	4809	MovableObjectMap* objectMap = getMovableObjectMap(m->getMovableType());
	4810	(*objectMap)[m->getName()] = m;
	4811	}
	4812	//---------------------------------------------------------------------
	4813	void SceneManager::extractMovableObject(const String& name, const String& typeName)
	4814	{
	4815	MovableObjectMap* objectMap = getMovableObjectMap(typeName);
	4816	MovableObjectMap::iterator mi = objectMap->find(name);
	4817	if (mi != objectMap->end())
	4818	{
	4819	// no delete
	4820	objectMap->erase(mi);
	4821	}
	4822
	4823	}
	4824	//---------------------------------------------------------------------
	4825	void SceneManager::extractMovableObject(MovableObject* m)
	4826	{
	4827	extractMovableObject(m->getName(), m->getMovableType());
	4828	}
	4829	//---------------------------------------------------------------------
	4830	void SceneManager::extractAllMovableObjectsByType(const String& typeName)
	4831	{
	4832	MovableObjectMap* objectMap = getMovableObjectMap(typeName);
	4833	// no deletion
	4834	objectMap->clear();
	4835
	4836	}
	4837	//---------------------------------------------------------------------
	4838	void SceneManager::_injectRenderWithPass(Pass pass, Renderable rend)
	4839	{
	4840	// render something as if it came from the current queue
	4841	const Pass *usedPass = _setPass(pass);
	4842	renderSingleObject(rend, usedPass, false);
	4843	}
	4844	//---------------------------------------------------------------------
	4845	RenderSystem *SceneManager::getDestinationRenderSystem()
	4846	{
	4847	return mDestRenderSystem;
	4848	}
	4849
	4850	}

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: OGRE/trunk/ogrenew/OgreMain/src/OgreSceneManager.cpp @ 692

Download in other formats: