Context Navigation

OgreSceneManager.cpp @ 692

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

Line
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: