Context Navigation

OgreSceneManager.cpp @ 657

Revision 657, 149.8 KB checked in by mattausch, 19 years ago (diff)
added ogre dependencies and patched ogre sources

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

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

Context Navigation

source: OGRE/trunk/ogre_changes/OgreMain/src/OgreSceneManager.cpp @ 657

Download in other formats: