Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/trunk/src/libraries/tools/bsp/OgreFramework.cpp @ 11367

Last change on this file since 11367 was 7163, checked in by dafrick, 14 years ago
Merged presentation3 branch into trunk.
Property svn:eol-style set to `native`
File size: 231.2 KB

Line
1	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2	/*
3	===========================================================================
4	Copyright (C) 2010 Jared Prince
5
6	This file is part of bsp-renderer source code.
7
8	bsp-renderer is free software: you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation, either version 3 of the License, or
11	(at your option) any later version.
12
13	bsp-renderer is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with bsp-renderer. If not, see <http://www.gnu.org/licenses/>.
20
21	*/
22
23	#include "OgreFramework.hpp"
24
25	#include <io.h>
26	#include <fcntl.h> /* Needed only for _O_RDWR definition */
27	#include <sys/stat.h>
28	#include "Q3Map_misc.h" // safe pointer deletes
29
30
31
32	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
33
34	using namespace Ogre;
35
36	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
37
38	template<> OgreFramework* Ogre::Singleton<class OgreFramework>::ms_Singleton = 0;
39
40
41
42	OgreFramework::OgreFramework()
43	{
44
45	m_nNewCount=0 ;
46	ZeroMemory((void*)m_nNewCheck, sizeof(m_nNewCheck)) ;
47
48	m_MoveSpeed = 0.1;
49	m_RotateSpeed = 0.3;
50
51	m_bShutDownOgre = false;
52	m_iNumScreenShots = 0;
53
54	m_pRoot = 0;
55	m_pSceneMgr = 0;
56	m_pRenderWnd = 0;
57	m_pCamera = 0;
58	m_pViewport = 0;
59	m_pLog = 0;
60	m_pTimer = 0;
61
62	m_pInputMgr = 0;
63	m_pKeyboard = 0;
64	m_pMouse = 0;
65
66	m_pDebugOverlay = 0;
67	m_pInfoOverlay = 0;
68
69	//mRawFileManager=NULL ; // pointer for text file resource handler
70	m_pRawBspFile=NULL ;
71	m_bRawBspFileIsLoaded=false ;
72
73	// pointers for q3map stuff
74	m_TempMem=NULL ;
75	m_Q3Map=NULL ;
76
77
78	m_pZoneMO=NULL ;
79	m_pZoneMesh=NULL ;
80	m_pZoneEntity=NULL ;
81	m_pZoneEntityMaterialType=NULL ;
82
83	int nPTex=0 ;
84	for(nPTex=0 ; nPTex<MAX_PROJECTORTEX ; nPTex++)
85	{
86	m_pZoneEntityMaterial_Base[nPTex]=NULL ;
87	m_pZoneEntityMaterial_Fast[nPTex]=NULL ;
88	}
89
90	m_pZoneEntityMaterial_Black=NULL ;
91
92	m_pZoneEntityMaterial_DfShColour=NULL ;
93	m_pZoneEntityMaterial_Shadow=NULL ;
94	m_pZoneEntityMaterial_ShadeFront=NULL ;
95	m_pZoneEntityMaterial_ShadeBack=NULL ;
96	m_pZoneEntityMaterial_DfShPosition=NULL ;
97	m_pZoneEntityMaterial_DfShDiffuse=NULL ;
98	//m_pZoneEntityMaterial_DSNormal=NULL ;
99	m_pZoneEntityMaterial_DfShFuncTNB=NULL ;
100	m_pZoneEntityMaterial_DfShSpecular=NULL ;
101	m_pZoneEntityMaterial_DfShEmissive=NULL ;
102	//m_pZoneEntityMaterial_DfShData=NULL ;
103	m_pZoneEntityMaterial_DfShMix=NULL ;
104
105
106	/////////////////////////////////
107
108	m_nMaxEntity=0 ;
109	m_pEntityInfo=NULL ;
110	m_nMaxVisibleEntity=0 ;
111	m_pVisibleEntity=NULL ;
112	m_nMaxFrustumEntity=0 ;
113	m_pFrustumEntity=NULL ;
114
115
116	// debug light meshes
117	m_pLightMO=NULL ;
118	m_pPortalMO=NULL ;
119	m_pPortalNode=NULL ;
120
121	m_pCubeNode = 0;
122	m_pCubeEntity = 0;
123
124	nMap=2 ;
125	m_nLoadToggle=0 ;
126	m_nJumpToggle=0 ;
127	m_nJumpVal=-1 ;
128
129
130
131
132
133	m_nDebugA=0 ;
134	m_nDebugB=0 ;
135	m_nDebugC=0 ;
136	m_nRecurseCount=0 ;
137
138
139	m_nDebugLightBox=0 ;
140	m_nZoneCullingActive=1 ;
141
142	m_nPortalDebug=0 ;
143	m_nPortalToggle=0 ;
144	m_nPortalState=1 ;
145
146	m_nKeyDown_Shift=0 ;
147	m_nKeyDown_Ctrl=0 ;
148
149
150
151	m_flStereoFrustumTweak=0.0f ;
152
153	m_nGoggleMode=GOGGLE_MODE_OFF ;
154	m_pGoggleL=NULL ;
155	m_pGoggleR=NULL ;
156	m_pNodeGoggles=NULL ;
157
158	// default goggle settings
159	m_flGoggleZPos=-250 ;
160	m_flGoggleXGap=0.0 ;
161	m_flGoggleXScale=1.0 ;
162	m_flGoggleYScale=1.0 ;
163
164	m_nMapLoaded=0 ;
165
166	m_nTime=0 ;
167
168
169
170	ZeroMemory((void*)m_nFrameTime, sizeof(m_nFrameTime)) ;
171	m_nFrame=0 ;
172	m_nGotInput=0 ;
173
174	ZeroMemory((void*)m_nKeyToggle, sizeof(m_nKeyToggle)) ;
175
176	// OFBug.LogInit() ;
177
178	m_nRTTAssetsExist=0 ;
179
180	m_nToggle=0 ;
181
182	m_nFlashLight=0 ;
183
184
185
186	m_flAspectRatio=1.0f ;
187	m_flFOV=60.0f ;
188
189	// whether we are drawing the render or one of the info screens, such as wireframe or one of the deferred screens
190	m_nDisplayInfoMode=0 ;
191
192	m_nSpeedRender=0 ;
193
194	//m_nRenderHDR=0 ;
195
196	srand( (unsigned)time( NULL ) );
197
198	}
199
200	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
201
202	OgreFramework::~OgreFramework()
203	{
204	// OFBug.LogSave("OFBug.txt") ;
205
206	/*
207	char chMessage[1024] ;
208	int nFrame=0 ;
209	m_pLog->logMessage(" ");
210	m_pLog->logMessage(" Mircosecs: Physics Render Ideal Average Pragma Total");
211	m_pLog->logMessage(" ----------------------------------------");
212	for(nFrame=0 ; nFrame<MAXFRAME ; nFrame++)
213	{
214	//sprintf(chMessage, " Frame %3i: %8i %8i %8i", nFrame, m_nFrameTime[nFrame][0], m_nFrameTime[nFrame][1], m_nFrameTime[nFrame][2]) ;
215	sprintf(chMessage, " Frame %3i: %8i %8i %8i %8i %8i %8i", nFrame, m_nFrameTime[nFrame][0], m_nFrameTime[nFrame][1], m_nFrameTime[nFrame][2], m_nFrameTime[nFrame][3], m_nFrameTime[nFrame][4], m_nFrameTime[nFrame][5]) ;
216	m_pLog->logMessage(chMessage);
217	}
218	m_pLog->logMessage("");
219	*/
220
221	//UnloadMap(true) ;
222
223
224	//mRawFileManager->~RawFileManager() ; //!! is this correct?
225	//DELETE_POINTER( mRawFileManager ) ;
226
227
228	DELETE_POINTER( m_pKeyboard );
229	DELETE_POINTER( m_pMouse );
230	OIS::InputManager::destroyInputSystem(m_pInputMgr);
231
232
233	//DELETE_POINTER( m_pRoot );
234	//delete m_pRoot ;
235	}
236
237
238
239	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
240
241	void OgreFramework::initOgre(Ogre::String wndTitle, OIS::KeyListener pKeyListener, OIS::MouseListener pMouseListener)
242	{
243	// Ogre::LogManager* logMgr = new Ogre::LogManager();
244
245	m_pLog = Ogre::LogManager::getSingleton().createLog("OgreLogfile.log", true, true, false);
246	m_pLog->setDebugOutputEnabled(true);
247
248	m_pRoot = new Ogre::Root();
249
250	// our manager for the raw bsp
251	//mRawFileManager = new RawFileManager();
252	//ResourceGroupManager::getSingleton().createResourceGroup("Raw Bsp") ;
253
254
255
256
257	m_pRoot->showConfigDialog();
258
259	if (!m_pRoot->restoreConfig() && !m_pRoot->showConfigDialog())
260	{
261	throw Exception(52, "User canceled the config dialog!", "Application::setupRenderSystem()");
262	}
263
264
265	m_pRenderWnd = m_pRoot->initialise(true, wndTitle);
266
267	m_pSceneMgr = m_pRoot->createSceneManager(ST_GENERIC, "SceneManager");
268	m_pSceneMgr->setAmbientLight(Ogre::ColourValue(0.0, 0.0, 0.0));
269
270
271	m_pCamera = m_pSceneMgr->createCamera("Camera");
272	m_pCamera->setPosition(Vector3(0, 0, 0));
273	m_pCamera->lookAt(Vector3(0,0,0));
274	m_pCamera->setNearClipDistance(NEARCLIP);
275	m_pCamera->setFarClipDistance(FARCLIP);
276	m_pCamera->setFOVy( Degree(m_flFOV) ) ;
277
278	m_pCameraCopy = m_pSceneMgr->createCamera("CameraCopy");
279	m_pCameraCopy->setNearClipDistance(NEARCLIP);
280	m_pCameraCopy->setFarClipDistance(FARCLIP);
281
282
283
284	m_pCameraNoJitter = m_pSceneMgr->createCamera("CameraNoJitter");
285
286
287
288
289
290	m_pViewport = m_pRenderWnd->addViewport(m_pCamera);
291
292	m_pViewport->setBackgroundColour(ColourValue(0.5, 0.5, 0.5, 1.0));
293
294	m_flAspectRatio= (float)m_pViewport->getActualWidth() / (float)m_pViewport->getActualHeight() ;
295
296	m_flGoggleAspectRatio=m_flAspectRatio ; // we use this to set up the Goggles
297	m_pCamera->setAspectRatio( Real(m_flAspectRatio) );
298	m_pCameraCopy->setAspectRatio( Real(m_flAspectRatio) );
299
300	m_pViewport->setCamera(m_pCamera);
301	m_pViewport->setClearEveryFrame(true);//, FBT_DEPTH) ;
302
303
304
305
306	unsigned long hWnd = 0;
307	OIS::ParamList paramList;
308	m_pRenderWnd->getCustomAttribute("WINDOW", &hWnd);
309
310	paramList.insert(OIS::ParamList::value_type("WINDOW", Ogre::StringConverter::toString(hWnd)));
311
312	m_pInputMgr = OIS::InputManager::createInputSystem(paramList);
313
314	m_pKeyboard = static_cast<OIS::Keyboard*>(m_pInputMgr->createInputObject(OIS::OISKeyboard, true));
315	m_pMouse = static_cast<OIS::Mouse*>(m_pInputMgr->createInputObject(OIS::OISMouse, true));
316
317
318	m_pMouse->getMouseState().height = m_pRenderWnd->getHeight();
319	m_pMouse->getMouseState().width = m_pRenderWnd->getWidth();
320
321	if(pKeyListener == 0)
322	m_pKeyboard->setEventCallback(this);
323	else
324	m_pKeyboard->setEventCallback(pKeyListener);
325
326	if(pMouseListener == 0)
327	m_pMouse->setEventCallback(this);
328	else
329	m_pMouse->setEventCallback(pMouseListener);
330
331	SetupResourceLocations() ;
332
333	// D3D or OGL
334	if (Root::getSingleton().getRenderSystem()->getName().find("GL") != String::npos)
335	m_IsOpenGL = true;
336	else
337	m_IsOpenGL = false;
338
339
340
341
342
343	m_pTimer = new Ogre::Timer();
344	m_pTimer->reset();
345
346
347
348
349
350	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
351
352	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
353
354
355
356
357
358
359	m_nRTTWidth = m_pRenderWnd->getWidth() ;
360	m_nRTTHeight = m_pRenderWnd->getHeight() ;
361
362
363	m_pRenderWnd->addListener(this);
364	m_pRenderWnd->setActive(true);
365
366
367	// default values, may be changed from the bzn.cfg file
368	m_nShadowMapSize=512 ;
369	m_nShadowRGBSize=512 ;
370	m_nColouredShadow=1 ;
371	m_nRenderHDR=1 ;
372	m_nMaxGPUQuery=1 ;
373
374	}
375
376	void OgreFramework::FinalShutdown(void)
377	{
378
379	//Ogre::ResourceGroupManager::getSingleton().shutdownAll();
380	//m_pRoot->destroySceneManager(m_pSceneMgr);
381	//m_pRoot->shutdown() ;
382	delete m_pRoot ;
383	}
384
385	void OgreFramework::AdditionalSetup()
386	{
387
388	CreateRTTAssets() ;
389	}
390
391
392	void OgreFramework::SetupResourceLocations()
393	{
394	Ogre::String secName, typeName, archName;
395	Ogre::ConfigFile cf;
396	cf.load("resources.cfg");
397
398	Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
399	while (seci.hasMoreElements())
400	{
401	secName = seci.peekNextKey();
402	Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
403	Ogre::ConfigFile::SettingsMultiMap::iterator i;
404	for (i = settings->begin(); i != settings->end(); ++i)
405	{
406	typeName = i->first;
407	archName = i->second;
408	Ogre::ResourceGroupManager::getSingleton().addResourceLocation(archName, typeName, secName);
409	}
410	}
411	Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
412	}
413
414
415	// create the textures, materials and miniscreens needed for the RTTs
416	void OgreFramework::CreateRTTAssets()
417	{
418
419
420	// I originally had problems with OpenGL 2.1.1 suddenly running very slow if I had more than 12 RTT surfaces
421	// but that issue seems to have vanished, perhaps because all my surfaces are now FLOAT16_RGB or FLOAT16_RGBA.
422	// It doesn't like FLOAT32 surfaces, and it also didn't seem to like mixing R8G8B8 with FLOAT16, at least
423	// those configurations seem to have been problems in the past, so I try to keep everything FLOAT16_RGB where possible.
424
425	// I go through quite a few RTT surfaces, and I don't use MRT since I couldn't get it working.
426
427	MaterialManager::getSingleton().initialise() ;
428
429	// need our own resource group so that the RTTs dont get destroyed when we load a new level.
430	Ogre::ResourceGroupManager::getSingleton().createResourceGroup("RTTResources") ;
431
432	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
433
434	int RTTWidth = m_nRTTWidth ;//m_pRenderWnd->getWidth() ;
435	int RTTHeight = m_nRTTHeight ; //m_pRenderWnd->getHeight() ;
436
437	int DSWidth = m_nRTTWidth ;
438	int DSHeight = m_nRTTHeight ;
439
440	int DSWidthB = m_nSpeedRender ? m_nRTTWidth/2 : m_nRTTWidth ;
441	int DSHeightB = m_nSpeedRender ? m_nRTTHeight/2 : m_nRTTHeight ;
442
443	int TEMPWidth = m_nRTTWidth ;
444	int TEMPHeight = m_nRTTHeight ;
445
446
447	Ogre::ColourValue ClearColour=Ogre::ColourValue(0,0,0,1) ; // clears alpha as well. for RGBA textures
448	//!! for now use alpha 1, since Ogre seems to force it to 1 anyway on shadow render.
449
450
451
452
453	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
454	// Shadow
455
456	RTT_Texture_Shadow = Ogre::TextureManager::getSingleton().createManual("RttTex_Shadow",
457	"RTTResources", TEX_TYPE_2D, m_nShadowMapSize, m_nShadowMapSize, 0, PF_FLOAT16_RGB,
458	TU_RENDERTARGET);
459
460
461	renderTexture_Shadow = RTT_Texture_Shadow->getBuffer()->getRenderTarget();
462	renderTexture_Shadow->addViewport(m_pCamera);
463	renderTexture_Shadow->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
464	renderTexture_Shadow->getViewport(0)->setBackgroundColour(ColourValue::White);
465	renderTexture_Shadow->getViewport(0)->setOverlaysEnabled(false);
466
467	RTT_Mat_Shadow = MaterialManager::getSingleton().create("RttMat_Shadow", "RTTResources");
468	RTT_Technique_Shadow = RTT_Mat_Shadow->createTechnique();
469	RTT_Technique_Shadow->createPass();
470	TextureUnitState* tState_Shadow = RTT_Mat_Shadow->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_Shadow");
471	tState_Shadow->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
472	RTT_Mat_Shadow->getTechnique(0)->getPass(0)->setLightingEnabled(false);
473	RTT_Mat_Shadow->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
474
475	miniScreen_Shadow = new Ogre::Rectangle2D(true);
476	miniScreen_Shadow->setCorners(-1.0001, 1.0001, 1.0, -1.0);
477	miniScreen_Shadow->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
478	miniScreenNode_Shadow = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_Shadow");
479	miniScreenNode_Shadow->attachObject(miniScreen_Shadow);
480	miniScreen_Shadow->setMaterial("RttMat_Shadow");
481
482
483	if(m_nColouredShadow)
484	{
485	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
486	// ShadeFront
487
488	RTT_Texture_ShadeFront = Ogre::TextureManager::getSingleton().createManual("RttTex_ShadeFront",
489	"RTTResources", TEX_TYPE_2D, m_nShadowRGBSize, m_nShadowRGBSize, 0, PF_FLOAT16_RGBA,
490	TU_RENDERTARGET);
491
492
493	renderTexture_ShadeFront = RTT_Texture_ShadeFront->getBuffer()->getRenderTarget();
494	renderTexture_ShadeFront->addViewport(m_pCamera);
495	renderTexture_ShadeFront->getViewport(0)->setClearEveryFrame(true);//, FBT_DEPTH);
496	renderTexture_ShadeFront->getViewport(0)->setBackgroundColour(ColourValue::White);
497	renderTexture_ShadeFront->getViewport(0)->setOverlaysEnabled(false);
498
499	RTT_Mat_ShadeFront = MaterialManager::getSingleton().create("RttMat_ShadeFront", "RTTResources");
500	RTT_Technique_ShadeFront = RTT_Mat_ShadeFront->createTechnique();
501	RTT_Technique_ShadeFront->createPass();
502	TextureUnitState* tState_ShadeFront = RTT_Mat_ShadeFront->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_ShadeFront");
503	tState_ShadeFront->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
504	RTT_Mat_ShadeFront->getTechnique(0)->getPass(0)->setLightingEnabled(false);
505	RTT_Mat_ShadeFront->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
506
507	miniScreen_ShadeFront = new Ogre::Rectangle2D(true);
508	miniScreen_ShadeFront->setCorners(-1.0001, 1.0001, 1.0, -1.0);
509	miniScreen_ShadeFront->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
510	miniScreenNode_ShadeFront = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_ShadeFront");
511	miniScreenNode_ShadeFront->attachObject(miniScreen_ShadeFront);
512	miniScreen_ShadeFront->setMaterial("RttMat_ShadeFront");
513
514	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
515	// ShadeBack
516
517	RTT_Texture_ShadeBack = Ogre::TextureManager::getSingleton().createManual("RttTex_ShadeBack",
518	"RTTResources", TEX_TYPE_2D, m_nShadowRGBSize, m_nShadowRGBSize, 0, PF_FLOAT16_RGBA,
519	TU_RENDERTARGET);
520
521
522	renderTexture_ShadeBack = RTT_Texture_ShadeBack->getBuffer()->getRenderTarget();
523	renderTexture_ShadeBack->addViewport(m_pCamera);
524	renderTexture_ShadeBack->getViewport(0)->setClearEveryFrame(true);//, FBT_DEPTH);
525	renderTexture_ShadeBack->getViewport(0)->setBackgroundColour(ColourValue::White);
526	renderTexture_ShadeBack->getViewport(0)->setOverlaysEnabled(false);
527
528	RTT_Mat_ShadeBack = MaterialManager::getSingleton().create("RttMat_ShadeBack", "RTTResources");
529	RTT_Technique_ShadeBack = RTT_Mat_ShadeBack->createTechnique();
530	RTT_Technique_ShadeBack->createPass();
531	TextureUnitState* tState_ShadeBack = RTT_Mat_ShadeBack->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_ShadeBack");
532	tState_ShadeBack->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
533	RTT_Mat_ShadeBack->getTechnique(0)->getPass(0)->setLightingEnabled(false);
534	RTT_Mat_ShadeBack->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
535
536	miniScreen_ShadeBack = new Ogre::Rectangle2D(true);
537	miniScreen_ShadeBack->setCorners(-1.0001, 1.0001, 1.0, -1.0);
538	miniScreen_ShadeBack->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
539	miniScreenNode_ShadeBack = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_ShadeBack");
540	miniScreenNode_ShadeBack->attachObject(miniScreen_ShadeBack);
541	miniScreen_ShadeBack->setMaterial("RttMat_ShadeBack");
542
543	} // end if coloured shadows
544
545
546	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
547	// DfShPosition
548
549	RTT_Texture_DfShPosition = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShPosition",
550	"RTTResources", TEX_TYPE_2D, DSWidth, DSHeight, 0, PF_FLOAT16_RGB,
551	TU_RENDERTARGET);
552
553
554	renderTexture_DfShPosition = RTT_Texture_DfShPosition->getBuffer()->getRenderTarget();
555	renderTexture_DfShPosition->addViewport(m_pCamera);
556	renderTexture_DfShPosition->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
557	renderTexture_DfShPosition->getViewport(0)->setBackgroundColour(ColourValue::Black);
558	renderTexture_DfShPosition->getViewport(0)->setOverlaysEnabled(false);
559
560	RTT_Mat_DfShPosition = MaterialManager::getSingleton().create("RttMat_DfShPosition", "RTTResources");
561	RTT_Technique_DfShPosition = RTT_Mat_DfShPosition->createTechnique();
562	RTT_Technique_DfShPosition->createPass();
563	TextureUnitState* tState_DfShPosition = RTT_Mat_DfShPosition->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShPosition");
564	tState_DfShPosition->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
565	RTT_Mat_DfShPosition->getTechnique(0)->getPass(0)->setLightingEnabled(false);
566	RTT_Mat_DfShPosition->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
567
568
569	//renderTexture_DfShPosition->addListener(this);
570
571	miniScreen_DfShPosition = new Ogre::Rectangle2D(true);
572	miniScreen_DfShPosition->setCorners(-1.0001, 1.0001, 1.0, -1.0);
573	miniScreen_DfShPosition->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
574	miniScreenNode_DfShPosition = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShPosition");
575	miniScreenNode_DfShPosition->attachObject(miniScreen_DfShPosition);
576	miniScreen_DfShPosition->setMaterial("RttMat_DfShPosition");
577
578
579
580	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
581	// DfShDiffuse
582
583	RTT_Texture_DfShDiffuse = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShDiffuse",
584	"RTTResources", TEX_TYPE_2D, DSWidth, DSHeight, 0, PF_FLOAT16_RGB,
585	TU_RENDERTARGET);
586
587
588	renderTexture_DfShDiffuse = RTT_Texture_DfShDiffuse->getBuffer()->getRenderTarget();
589	renderTexture_DfShDiffuse->addViewport(m_pCamera);
590	renderTexture_DfShDiffuse->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
591	renderTexture_DfShDiffuse->getViewport(0)->setBackgroundColour(ColourValue::Black);
592	renderTexture_DfShDiffuse->getViewport(0)->setOverlaysEnabled(false);
593
594	RTT_Mat_DfShDiffuse = MaterialManager::getSingleton().create("RttMat_DfShDiffuse", "RTTResources");
595	RTT_Technique_DfShDiffuse = RTT_Mat_DfShDiffuse->createTechnique();
596	RTT_Technique_DfShDiffuse->createPass();
597	TextureUnitState* tState_DfShDiffuse = RTT_Mat_DfShDiffuse->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShDiffuse");
598	tState_DfShDiffuse->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
599	RTT_Mat_DfShDiffuse->getTechnique(0)->getPass(0)->setLightingEnabled(false);
600	RTT_Mat_DfShDiffuse->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
601
602
603	//renderTexture_DfShDiffuse->addListener(this);
604
605	miniScreen_DfShDiffuse = new Ogre::Rectangle2D(true);
606	miniScreen_DfShDiffuse->setCorners(-1.0001, 1.0001, 1.0, -1.0);
607	miniScreen_DfShDiffuse->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
608	miniScreenNode_DfShDiffuse = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShDiffuse");
609	miniScreenNode_DfShDiffuse->attachObject(miniScreen_DfShDiffuse);
610	miniScreen_DfShDiffuse->setMaterial("RttMat_DfShDiffuse");
611
612	/*
613	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
614	// DSNormal
615
616	RTT_Texture_DSNormal = Ogre::TextureManager::getSingleton().createManual("RttTex_DSNormal",
617	"RTTResources", TEX_TYPE_2D, DSWidth, DSHeight, 0, PF_FLOAT16_RGB,
618	TU_RENDERTARGET);
619
620
621	renderTexture_DSNormal = RTT_Texture_DSNormal->getBuffer()->getRenderTarget();
622	renderTexture_DSNormal->addViewport(m_pCamera);
623	renderTexture_DSNormal->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
624	renderTexture_DSNormal->getViewport(0)->setBackgroundColour(ColourValue::Black);
625	renderTexture_DSNormal->getViewport(0)->setOverlaysEnabled(false);
626
627	RTT_Mat_DSNormal = MaterialManager::getSingleton().create("RttMat_DSNormal", "RTTResources");
628	RTT_Technique_DSNormal = RTT_Mat_DSNormal->createTechnique();
629	RTT_Technique_DSNormal->createPass();
630	TextureUnitState* tState_DSNormal = RTT_Mat_DSNormal->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DSNormal");
631	tState_DSNormal->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
632	RTT_Mat_DSNormal->getTechnique(0)->getPass(0)->setLightingEnabled(false);
633	RTT_Mat_DSNormal->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
634
635
636
637	//renderTexture_DSNormal->addListener(this);
638
639	miniScreen_DSNormal = new Ogre::Rectangle2D(true);
640	miniScreen_DSNormal->setCorners(-1.0001, 1.0001, 1.0, -1.0);
641	miniScreen_DSNormal->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
642	miniScreenNode_DSNormal = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DSNormal");
643	miniScreenNode_DSNormal->attachObject(miniScreen_DSNormal);
644	miniScreen_DSNormal->setMaterial("RttMat_DSNormal");
645
646	*/
647
648
649	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
650	// DfShFuncTNB
651
652	RTT_Texture_DfShFuncTNB = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShFuncTNB",
653	"RTTResources", TEX_TYPE_2D, DSWidth, DSHeight, 0, PF_FLOAT16_RGB,
654	TU_RENDERTARGET);
655
656
657	renderTexture_DfShFuncTNB = RTT_Texture_DfShFuncTNB->getBuffer()->getRenderTarget();
658	renderTexture_DfShFuncTNB->addViewport(m_pCamera);
659	renderTexture_DfShFuncTNB->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
660	renderTexture_DfShFuncTNB->getViewport(0)->setBackgroundColour(ColourValue::Black);
661	renderTexture_DfShFuncTNB->getViewport(0)->setOverlaysEnabled(false);
662
663	RTT_Mat_DfShFuncTNB = MaterialManager::getSingleton().create("RttMat_DfShFuncTNB", "RTTResources");
664	RTT_Technique_DfShFuncTNB = RTT_Mat_DfShFuncTNB->createTechnique();
665	RTT_Technique_DfShFuncTNB->createPass();
666	TextureUnitState* tState_DfShFuncTNB = RTT_Mat_DfShFuncTNB->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShFuncTNB");
667	tState_DfShFuncTNB->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
668	RTT_Mat_DfShFuncTNB->getTechnique(0)->getPass(0)->setLightingEnabled(false);
669	RTT_Mat_DfShFuncTNB->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
670
671	//renderTexture_DfShFuncTNB->addListener(this);
672
673	miniScreen_DfShFuncTNB = new Ogre::Rectangle2D(true);
674	miniScreen_DfShFuncTNB->setCorners(-1.0001, 1.0001, 1.0, -1.0);
675	miniScreen_DfShFuncTNB->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
676	miniScreenNode_DfShFuncTNB = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShFuncTNB");
677	miniScreenNode_DfShFuncTNB->attachObject(miniScreen_DfShFuncTNB);
678	miniScreen_DfShFuncTNB->setMaterial("RttMat_DfShFuncTNB");
679
680
681
682	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
683	// DfShSpecular
684
685	RTT_Texture_DfShSpecular = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShSpecular",
686	"RTTResources", TEX_TYPE_2D, DSWidthB, DSHeightB, 0, PF_FLOAT16_RGBA,
687	TU_RENDERTARGET);
688
689
690	renderTexture_DfShSpecular = RTT_Texture_DfShSpecular->getBuffer()->getRenderTarget();
691	renderTexture_DfShSpecular->addViewport(m_pCamera);
692	renderTexture_DfShSpecular->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
693	renderTexture_DfShSpecular->getViewport(0)->setBackgroundColour(ColourValue::Black);
694	renderTexture_DfShSpecular->getViewport(0)->setOverlaysEnabled(false);
695
696	RTT_Mat_DfShSpecular = MaterialManager::getSingleton().create("RttMat_DfShSpecular", "RTTResources");
697	RTT_Technique_DfShSpecular = RTT_Mat_DfShSpecular->createTechnique();
698	RTT_Technique_DfShSpecular->createPass();
699	TextureUnitState* tState_DfShSpecular = RTT_Mat_DfShSpecular->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShSpecular");
700	tState_DfShSpecular->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
701	RTT_Mat_DfShSpecular->getTechnique(0)->getPass(0)->setLightingEnabled(false);
702	if(m_nSpeedRender)
703	RTT_Mat_DfShSpecular->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_BILINEAR) ;
704	else
705	RTT_Mat_DfShSpecular->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
706
707
708	//renderTexture_DfShSpecular->addListener(this);
709
710	miniScreen_DfShSpecular = new Ogre::Rectangle2D(true);
711	miniScreen_DfShSpecular->setCorners(-1.0001, 1.0001, 1.0, -1.0);
712	miniScreen_DfShSpecular->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
713	miniScreenNode_DfShSpecular = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShSpecular");
714	miniScreenNode_DfShSpecular->attachObject(miniScreen_DfShSpecular);
715	miniScreen_DfShSpecular->setMaterial("RttMat_DfShSpecular");
716
717	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
718	// DfShEmissive
719
720	RTT_Texture_DfShEmissive = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShEmissive",
721	"RTTResources", TEX_TYPE_2D, DSWidth, DSHeight, 0, PF_FLOAT16_RGB,
722	TU_RENDERTARGET);
723
724
725	renderTexture_DfShEmissive = RTT_Texture_DfShEmissive->getBuffer()->getRenderTarget();
726	renderTexture_DfShEmissive->addViewport(m_pCamera);
727	renderTexture_DfShEmissive->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
728	renderTexture_DfShEmissive->getViewport(0)->setBackgroundColour(ColourValue::Black);
729	renderTexture_DfShEmissive->getViewport(0)->setOverlaysEnabled(false);
730
731	RTT_Mat_DfShEmissive = MaterialManager::getSingleton().create("RttMat_DfShEmissive", "RTTResources");
732	RTT_Technique_DfShEmissive = RTT_Mat_DfShEmissive->createTechnique();
733	RTT_Technique_DfShEmissive->createPass();
734	TextureUnitState* tState_DfShEmissive = RTT_Mat_DfShEmissive->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShEmissive");
735	tState_DfShEmissive->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
736	RTT_Mat_DfShEmissive->getTechnique(0)->getPass(0)->setLightingEnabled(false);
737	if(m_nSpeedRender)
738	RTT_Mat_DfShEmissive->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_BILINEAR) ;
739	else
740	RTT_Mat_DfShEmissive->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
741
742
743	//renderTexture_DfShEmissive->addListener(this);
744
745	miniScreen_DfShEmissive = new Ogre::Rectangle2D(true);
746	miniScreen_DfShEmissive->setCorners(-1.0001, 1.0001, 1.0, -1.0);
747	miniScreen_DfShEmissive->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
748	miniScreenNode_DfShEmissive = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShEmissive");
749	miniScreenNode_DfShEmissive->attachObject(miniScreen_DfShEmissive);
750	miniScreen_DfShEmissive->setMaterial("RttMat_DfShEmissive");
751
752
753	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
754	// DfShLamp
755
756	RTT_Texture_DfShLamp = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShLamp",
757	"RTTResources", TEX_TYPE_2D, DSWidth, DSHeight, 0, PF_FLOAT16_RGB,
758	TU_RENDERTARGET);//, 0, false, 6);
759
760	renderTexture_DfShLamp = RTT_Texture_DfShLamp->getBuffer()->getRenderTarget();
761	renderTexture_DfShLamp->addViewport(m_pCamera);
762	renderTexture_DfShLamp->getViewport(0)->setClearEveryFrame(true);//, FBT_DEPTH);
763	renderTexture_DfShLamp->getViewport(0)->setBackgroundColour(ColourValue::Black);
764	renderTexture_DfShLamp->getViewport(0)->setOverlaysEnabled(false);
765
766	RTT_Mat_DfShLamp = MaterialManager::getSingleton().create("RttMat_DfShLamp", "RTTResources");
767	RTT_Technique_DfShLamp = RTT_Mat_DfShLamp->createTechnique();
768	RTT_Technique_DfShLamp->createPass();
769	TextureUnitState* tState_DfShLamp = RTT_Mat_DfShLamp->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShLamp");
770	tState_DfShLamp->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
771	RTT_Mat_DfShLamp->getTechnique(0)->getPass(0)->setLightingEnabled(false);
772	RTT_Mat_DfShLamp->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
773	//renderTexture_DfShLamp->addListener(this);
774
775	miniScreen_DfShLamp = new Ogre::Rectangle2D(true);
776	miniScreen_DfShLamp->setCorners(-1.0001, 1.0001, 1.0, -1.0);
777	miniScreen_DfShLamp->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
778	miniScreenNode_DfShLamp = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShLamp");
779	miniScreenNode_DfShLamp->attachObject(miniScreen_DfShLamp);
780	miniScreen_DfShLamp->setMaterial("RttMat_DfShLamp");
781
782
783
784	/*
785	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
786	// DfShData
787
788	RTT_Texture_DfShData = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShData",
789	"RTTResources", TEX_TYPE_2D, DSWidthB, DSHeightB, 0, PF_FLOAT16_RGB,
790	TU_RENDERTARGET);
791
792	renderTexture_DfShData = RTT_Texture_DfShData->getBuffer()->getRenderTarget();
793	renderTexture_DfShData->addViewport(m_pCamera);
794	renderTexture_DfShData->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
795	renderTexture_DfShData->getViewport(0)->setBackgroundColour(ColourValue::Black);
796	renderTexture_DfShData->getViewport(0)->setOverlaysEnabled(false);
797
798	RTT_Mat_DfShData = MaterialManager::getSingleton().create("RttMat_DfShData", "RTTResources");
799	RTT_Technique_DfShData = RTT_Mat_DfShData->createTechnique();
800	RTT_Technique_DfShData->createPass();
801	TextureUnitState* tState_DfShData = RTT_Mat_DfShData->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShData");
802	tState_DfShData->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
803	RTT_Mat_DfShData->getTechnique(0)->getPass(0)->setLightingEnabled(false);
804	if(m_nSpeedRender)
805	RTT_Mat_DfShData->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_BILINEAR) ;
806	else
807	RTT_Mat_DfShData->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
808	//renderTexture_DfShData->addListener(this);
809
810	miniScreen_DfShData = new Ogre::Rectangle2D(true);
811	miniScreen_DfShData->setCorners(-1.0001, 1.0001, 1.0, -1.0);
812	miniScreen_DfShData->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
813	miniScreenNode_DfShData = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShData");
814	miniScreenNode_DfShData->attachObject(miniScreen_DfShData);
815	miniScreen_DfShData->setMaterial("RttMat_DfShData");
816
817	*/
818
819
820	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
821	// DfShTemp
822
823	RTT_Texture_DfShTemp = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShTemp",
824	"RTTResources", TEX_TYPE_2D, TEMPWidth, TEMPHeight, 0, PF_FLOAT16_RGB,
825	TU_RENDERTARGET);//, 0, false, 6);
826
827	renderTexture_DfShTemp = RTT_Texture_DfShTemp->getBuffer()->getRenderTarget();
828	renderTexture_DfShTemp->addViewport(m_pCamera);
829	renderTexture_DfShTemp->getViewport(0)->setClearEveryFrame(true, FBT_DEPTH);
830	renderTexture_DfShTemp->getViewport(0)->setBackgroundColour(ColourValue::Black);
831	renderTexture_DfShTemp->getViewport(0)->setOverlaysEnabled(false);
832
833	RTT_Mat_DfShTemp = MaterialManager::getSingleton().create("RttMat_DfShTemp", "RTTResources");
834	RTT_Technique_DfShTemp = RTT_Mat_DfShTemp->createTechnique();
835	RTT_Technique_DfShTemp->createPass();
836	TextureUnitState* tState_DfShTemp = RTT_Mat_DfShTemp->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShTemp");
837	tState_DfShTemp->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
838	RTT_Mat_DfShTemp->getTechnique(0)->getPass(0)->setLightingEnabled(false);
839	RTT_Mat_DfShTemp->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
840	//renderTexture_DfShTemp->addListener(this);
841
842	miniScreen_DfShTemp = new Ogre::Rectangle2D(true);
843	miniScreen_DfShTemp->setCorners(-1.0001, 1.0001, 1.0, -1.0);
844	miniScreen_DfShTemp->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
845	miniScreenNode_DfShTemp = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShTemp");
846	miniScreenNode_DfShTemp->attachObject(miniScreen_DfShTemp);
847	miniScreen_DfShTemp->setMaterial("RttMat_DfShTemp");
848
849
850
851	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
852	// DfShMix
853
854	RTT_Texture_DfShMix = Ogre::TextureManager::getSingleton().createManual("RttTex_DfShMix",
855	"RTTResources", TEX_TYPE_2D, RTTWidth, RTTHeight, 0, PF_FLOAT16_RGB,
856	TU_RENDERTARGET);
857
858
859	renderTexture_DfShMix = RTT_Texture_DfShMix->getBuffer()->getRenderTarget();
860	renderTexture_DfShMix->addViewport(m_pCamera);
861	renderTexture_DfShMix->getViewport(0)->setClearEveryFrame(false);//, FBT_DEPTH);
862	renderTexture_DfShMix->getViewport(0)->setBackgroundColour(ColourValue::Black);
863	renderTexture_DfShMix->getViewport(0)->setOverlaysEnabled(false);
864
865	RTT_Mat_DfShMix = MaterialManager::getSingleton().create("RttMat_DfShMix", "RTTResources");
866	RTT_Technique_DfShMix = RTT_Mat_DfShMix->createTechnique();
867	RTT_Technique_DfShMix->createPass();
868	TextureUnitState* tState_DfShMix = RTT_Mat_DfShMix->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_DfShMix");
869	tState_DfShMix->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
870	RTT_Mat_DfShMix->getTechnique(0)->getPass(0)->setLightingEnabled(false);
871	RTT_Mat_DfShMix->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_NONE) ;
872
873
874	miniScreen_DfShMix = new Ogre::Rectangle2D(true);
875	miniScreen_DfShMix->setCorners(-1.0001, 1.0001, 1.0, -1.0);
876	miniScreen_DfShMix->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
877	miniScreenNode_DfShMix = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShMix");
878	miniScreenNode_DfShMix->attachObject(miniScreen_DfShMix);
879	miniScreen_DfShMix->setMaterial("RttMat_DfShMix");
880
881	if(m_nRenderHDR)
882	{
883
884
885	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
886	// BlurA
887
888	RTT_Texture_BlurA = Ogre::TextureManager::getSingleton().createManual("RttTex_BlurA",
889	"RTTResources", TEX_TYPE_2D, DSWidth/2, DSHeight/2, 0, PF_FLOAT16_RGB,
890	TU_RENDERTARGET);
891
892	renderTexture_BlurA = RTT_Texture_BlurA->getBuffer()->getRenderTarget();
893	renderTexture_BlurA->addViewport(m_pCamera);
894	renderTexture_BlurA->getViewport(0)->setClearEveryFrame(false);
895	renderTexture_BlurA->getViewport(0)->setBackgroundColour(ColourValue::Black);
896	renderTexture_BlurA->getViewport(0)->setOverlaysEnabled(false);
897
898	RTT_Mat_BlurA = MaterialManager::getSingleton().create("RttMat_BlurA", "RTTResources");
899	RTT_Technique_BlurA = RTT_Mat_BlurA->createTechnique();
900	RTT_Technique_BlurA->createPass();
901	TextureUnitState* tState_BlurA = RTT_Mat_BlurA->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_BlurA");
902	tState_BlurA->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
903	RTT_Mat_BlurA->getTechnique(0)->getPass(0)->setLightingEnabled(false);
904	RTT_Mat_BlurA->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_BILINEAR) ;
905
906	miniScreen_BlurA = new Ogre::Rectangle2D(true);
907	miniScreen_BlurA->setCorners(-1.0001, 1.0001, 1.0, -1.0);
908	miniScreen_BlurA->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
909	miniScreenNode_BlurA = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_BlurA");
910	miniScreenNode_BlurA->attachObject(miniScreen_BlurA);
911	miniScreen_BlurA->setMaterial("RttMat_BlurA");
912
913	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
914	// BlurB
915
916	RTT_Texture_BlurB = Ogre::TextureManager::getSingleton().createManual("RttTex_BlurB",
917	"RTTResources", TEX_TYPE_2D, DSWidth/2, DSHeight/2, 0, PF_FLOAT16_RGB,
918	TU_RENDERTARGET);
919
920	renderTexture_BlurB = RTT_Texture_BlurB->getBuffer()->getRenderTarget();
921	renderTexture_BlurB->addViewport(m_pCamera);
922	renderTexture_BlurB->getViewport(0)->setClearEveryFrame(false);
923	renderTexture_BlurB->getViewport(0)->setBackgroundColour(ColourValue::Black);
924	renderTexture_BlurB->getViewport(0)->setOverlaysEnabled(false);
925
926	RTT_Mat_BlurB = MaterialManager::getSingleton().create("RttMat_BlurB", "RTTResources");
927	RTT_Technique_BlurB = RTT_Mat_BlurB->createTechnique();
928	RTT_Technique_BlurB->createPass();
929	TextureUnitState* tState_BlurB = RTT_Mat_BlurB->getTechnique(0)->getPass(0)->createTextureUnitState("RttTex_BlurB");
930	tState_BlurB->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
931	RTT_Mat_BlurB->getTechnique(0)->getPass(0)->setLightingEnabled(false);
932	RTT_Mat_BlurB->getTechnique(0)->getPass(0)->setTextureFiltering(TFO_BILINEAR) ;
933
934	miniScreen_BlurB = new Ogre::Rectangle2D(true);
935	miniScreen_BlurB->setCorners(-1.0001, 1.0001, 1.0, -1.0);
936	miniScreen_BlurB->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
937	miniScreenNode_BlurB = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_BlurB");
938	miniScreenNode_BlurB->attachObject(miniScreen_BlurB);
939	miniScreen_BlurB->setMaterial("RttMat_BlurB");
940
941	} // end if m_nRenderHDR
942
943	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
944	// mixing quad
945	miniScreen_DfShMaster = new Ogre::Rectangle2D(true);
946	miniScreen_DfShMaster->setCorners(-1.0001, 1.0001, 1.0, -1.0);
947	miniScreen_DfShMaster->setBoundingBox(AxisAlignedBox(-100000.0Vector3::UNIT_SCALE, 100000.0Vector3::UNIT_SCALE));
948	miniScreenNode_DfShMaster = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("MiniScreenNode_DfShMaster");
949	miniScreenNode_DfShMaster->attachObject(miniScreen_DfShMaster);
950	//miniScreen_DfShMaster->setMaterial("RttMat_DfShDiffuse") ;
951	//miniScreen_DfShMaster->setMaterial("DfShMix") ; // doesn't matter what material we use, since we mix from pre-rendered textures
952
953	//RTT_Mat_Shadow->getTechnique(0)->getPass(0)->getTextureUnitState("RttTex_Shadow")->setTextureAddressingMode(Ogre::TextureUnitState::TAM_CLAMP) ;
954
955	}
956
957	void OgreFramework::DestroyRTTAssets()
958	{
959	}
960
961	void OgreFramework::UpdateRenderTargets()
962	{
963
964	int nZoneList=0 ;
965	int nZone=0 ;
966	Ogre::Entity* pEntity=NULL ;
967	int nMO=0 ;
968	int nZGStart=0 ;
969	int nZGEnd=0 ;
970
971	int nVisEnt=0 ;
972	int nEntity=0 ;
973	// int nMaxEntity=0 ;
974	int nSubMesh=0 ;
975	int nMaxSubMesh=0 ;
976
977	int nMaxVisibleZone=*m_pGlobal_MaxVisibleZone ;
978
979	SetAllLightsOff() ;
980
981
982	// extra texture params
983	// TexParam.x is 1 for d3d, -1 for ogl, needed for screen space UV calculations y flip
984	// TexParam.y is game time, in 1/10th of a second since start of level
985
986	Ogre::Vector4 TexParam ;
987	if(m_IsOpenGL)
988	TexParam.x=-1 ;
989	else
990	TexParam.x= 1 ;
991	TexParam.y=m_GameTime/100 ;
992	TexParam.z=512.0f ; // pixelnoise subdivisions for the emmissive data function.
993
994
995	// remove all the nodes, so we start with a clean slate
996	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ; // remove all the objects
997
998
999	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1000	//
1001	// deferred shading data textures
1002	//
1003	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1004
1005	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_OPAQUE) ;
1006
1007	// attach the entity masternode, update positions and orientations
1008	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1009	{
1010	nEntity=m_pFrustumEntity[nVisEnt] ;
1011	m_pEntityInfo[ nEntity ].pMasterNode->setPosition( m_pEntityInfo[nEntity].Postition ) ; // set position.
1012	m_pSceneMgr->getRootSceneNode()->addChild(m_pEntityInfo[ nEntity ].pMasterNode) ;
1013	}
1014
1015
1016
1017
1018	/////////////////////////////////////////////////////////////////////
1019	// DfShPosition
1020
1021	// change material
1022	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1023	{
1024	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1025	nZGStart = m_nZoneMOStart[nZone] ;
1026	nZGEnd = m_nZoneMOStart[nZone+1] ;
1027
1028	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1029	if(m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE)
1030	{
1031	pEntity=m_pZoneEntity[nMO] ;
1032	pEntity->setMaterial( m_pZoneEntityMaterial_DfShPosition[nMO] ) ;
1033	}// end for entities
1034
1035	}// end for zonelist
1036
1037
1038	// first time we set materials we need to set non-opaque to the be invisible. After we don't need to do it, they'll already be invisible
1039	// Set the entity material
1040
1041	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1042	{
1043	nEntity=m_pFrustumEntity[nVisEnt] ;
1044	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1045
1046	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1047	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE)
1048	{
1049	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_DfShPosition[nSubMesh] ) ;
1050	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(true) ; // first time around, make sure it is visible
1051	}
1052	else
1053	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(false) ;
1054	}
1055
1056
1057
1058	renderTexture_DfShPosition->update(true) ;
1059
1060	/////////////////////////////////////////////////////////////////////
1061	// DfShFuncTNB
1062
1063	// change material
1064	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1065	{
1066	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1067	nZGStart = m_nZoneMOStart[nZone] ;
1068	nZGEnd = m_nZoneMOStart[nZone+1] ;
1069
1070	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1071	if(m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE)
1072	{
1073	pEntity=m_pZoneEntity[nMO] ;
1074	pEntity->setMaterial( m_pZoneEntityMaterial_DfShFuncTNB[nMO] ) ;
1075	}// end for entities
1076
1077	}// end for zonelist
1078
1079	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1080	{
1081	nEntity=m_pFrustumEntity[nVisEnt] ;
1082	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1083
1084	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1085	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE)
1086	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_DfShFuncTNB[nSubMesh] ) ;
1087	}
1088
1089
1090	renderTexture_DfShFuncTNB->update(true) ;
1091
1092
1093	/////////////////////////////////////////////////////////////////////
1094	// DfShDiffuse
1095
1096	// the diffuse pass is used for the wireframe render as well
1097
1098
1099
1100	if(m_nDisplayInfoMode!=1)
1101	{
1102	// change material
1103	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1104	{
1105	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1106	nZGStart = m_nZoneMOStart[nZone] ;
1107	nZGEnd = m_nZoneMOStart[nZone+1] ;
1108
1109	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1110	if(m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE)
1111	{
1112	pEntity=m_pZoneEntity[nMO] ;
1113	pEntity->setMaterial( m_pZoneEntityMaterial_DfShDiffuse[nMO] ) ;
1114	}// end for entities
1115
1116	}// end for zonelist
1117
1118	// set the entity material
1119
1120	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1121	{
1122	nEntity=m_pFrustumEntity[nVisEnt] ;
1123	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1124
1125	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1126	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE)
1127	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_DfShDiffuse[nSubMesh] ) ;
1128	}
1129
1130
1131	renderTexture_DfShDiffuse->update(true) ;
1132	}
1133	else // if we are doing wireframe we use this pass for it
1134	{
1135	// add gels just for the wireframe
1136	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_GEL) ;
1137
1138
1139	// clear the RTT texture, since our wireframe won't clear it.
1140	m_pRoot->getRenderSystem()->_setViewport(renderTexture_DfShDiffuse->getViewport(0)) ;
1141	m_pRoot->getRenderSystem()->clearFrameBuffer(FBT_COLOUR\|FBT_DEPTH, Ogre::ColourValue(0,0,0,1)) ;
1142
1143	// set the camera to wireframe mode
1144	m_pCamera->setPolygonMode(PM_WIREFRAME);
1145
1146	// change material
1147	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1148	{
1149	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1150	nZGStart = m_nZoneMOStart[nZone] ;
1151	nZGEnd = m_nZoneMOStart[nZone+1] ;
1152
1153	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1154	if((m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE) \|\| (m_pZoneEntityMaterialType[nMO]==MAT_GEL))
1155	{
1156	pEntity=m_pZoneEntity[nMO] ;
1157	pEntity->setMaterial( MaterialManager::getSingleton().getByName("White") ) ;
1158	}// end for entities
1159
1160	}// end for zonelist
1161
1162	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1163	{
1164	nEntity=m_pFrustumEntity[nVisEnt] ;
1165	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1166
1167	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1168	{
1169	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]!=MAT_OPAQUE) // any non-opaque submeshes need to be made visible
1170	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(true) ;
1171
1172	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial(MaterialManager::getSingleton().getByName("White") ) ;
1173	}
1174	}
1175
1176	renderTexture_DfShDiffuse->update(true) ;
1177
1178	// reset back to pre-wireframe setup
1179	m_pCamera->setPolygonMode(PM_SOLID);
1180
1181	// remove everything and then add back OPAQUE
1182	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ; // remove all the objects
1183	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_OPAQUE) ;
1184
1185
1186	// reattach entities, make non-opaque subentities invisible
1187	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1188	{
1189	nEntity=m_pFrustumEntity[nVisEnt] ;
1190	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1191
1192	m_pSceneMgr->getRootSceneNode()->addChild(m_pEntityInfo[ nEntity ].pMasterNode) ;
1193
1194	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1195	{
1196	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]!=MAT_OPAQUE)
1197	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(false) ;
1198	}
1199	}
1200
1201
1202
1203	}
1204
1205
1206
1207	/////////////////////////////////////////////////////////////////////
1208	// DfShSpecular
1209
1210	// change material
1211	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1212	{
1213	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1214	nZGStart = m_nZoneMOStart[nZone] ;
1215	nZGEnd = m_nZoneMOStart[nZone+1] ;
1216
1217	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1218	if(m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE)
1219	{
1220	pEntity=m_pZoneEntity[nMO] ;
1221	pEntity->setMaterial( m_pZoneEntityMaterial_DfShSpecular[nMO] ) ;
1222	}// end for entities
1223
1224	}// end for zonelist
1225
1226	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1227	{
1228	nEntity=m_pFrustumEntity[nVisEnt] ;
1229	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1230
1231	// set the entity material
1232	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1233	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE)
1234	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_DfShSpecular[nSubMesh] ) ;
1235	}
1236
1237	renderTexture_DfShSpecular->update(true) ;
1238
1239	/*
1240	/////////////////////////////////////////////////////////////////////
1241	// DfShData
1242
1243	// change material
1244	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1245	{
1246	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1247	nZGStart = m_nZoneMOStart[nZone] ;
1248	nZGEnd = m_nZoneMOStart[nZone+1] ;
1249
1250	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1251	if(m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE)
1252	{
1253	pEntity=m_pZoneEntity[nMO] ;
1254	pEntity->setMaterial( m_pZoneEntityMaterial_DfShData[nMO] ) ;
1255	}// end for entities
1256
1257	}// end for zonelist
1258
1259	renderTexture_DfShData->update(true) ;
1260	*/
1261
1262
1263	/////////////////////////////////////////////////////////////////////
1264	// DfShEmissive
1265
1266	// we add the glow entities for this pass, if we are doing HDR
1267	if(m_nRenderHDR)
1268	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_GLOW) ;
1269
1270
1271	// change material
1272	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1273	{
1274	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1275	nZGStart = m_nZoneMOStart[nZone] ;
1276	nZGEnd = m_nZoneMOStart[nZone+1] ;
1277
1278	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1279	if((m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE) \|\| (m_pZoneEntityMaterialType[nMO]==MAT_GLOW))
1280	{
1281	pEntity=m_pZoneEntity[nMO] ;
1282	pEntity->setMaterial( m_pZoneEntityMaterial_DfShEmissive[nMO] ) ;
1283
1284	TexParam.z=512.0f ; // pixelnoise subdivisions for the emmissive data function.
1285	pEntity->getSubEntity(0)->setCustomParameter(4, TexParam) ; // emissive makes use of gametime for some lighting effects
1286	}// end for entities
1287
1288	}// end for zonelist
1289
1290	// set the entity material
1291	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1292	{
1293	nEntity=m_pFrustumEntity[nVisEnt] ;
1294	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1295
1296	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1297	if((m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE) \|\| (m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GLOW))
1298	{
1299	// make glow stuff visible
1300	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GLOW)
1301	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(true) ;
1302
1303	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_DfShEmissive[nSubMesh] ) ;
1304	}
1305	}
1306
1307	renderTexture_DfShEmissive->update(true) ;
1308
1309
1310
1311	////////////////////////////////////////////////////////////////////
1312	// we need to know how to colour stuff if we're seeing it through gel
1313	// this colouring will be applied when we mix lamp and emmissive down to DfShMix
1314	//
1315	// Note that this leaves the light/lamp glow entities attached in HDR mode,
1316	// we need them to block the gels otherwise the blur on the lights/lamps
1317	// comes out incorrectly coloured by gel that should be behind it.
1318
1319	// add the transparent stuff
1320	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_GEL) ;
1321
1322	// change material
1323	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1324	{
1325	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1326	nZGStart = m_nZoneMOStart[nZone] ;
1327	nZGEnd = m_nZoneMOStart[nZone+1] ;
1328
1329	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1330	if((m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE) \|\| (m_pZoneEntityMaterialType[nMO]==MAT_GEL) \|\| (m_pZoneEntityMaterialType[nMO]==MAT_GLOW))
1331	{
1332	pEntity=m_pZoneEntity[nMO] ;
1333	pEntity->setMaterial( m_pZoneEntityMaterial_DfShColour[nMO] ) ;
1334	}// end for entities
1335
1336
1337	}// end for zonelist
1338
1339	for(nVisEnt=0 ; nVisEnt<m_nMaxFrustumEntity ; nVisEnt++)
1340	{
1341	nEntity=m_pFrustumEntity[nVisEnt] ;
1342	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1343
1344	// set the entity material
1345	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1346	if((m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE) \|\| (m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GEL) \|\| (m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GLOW))
1347	{
1348	// make gel stuff visible (glow was already made visible on the emissive pass)
1349	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GEL)
1350	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(true) ;
1351
1352	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_DfShColour[nSubMesh] ) ;
1353	}
1354	}
1355
1356	// render colour to the temp surface
1357	renderTexture_DfShTemp->update(true) ;
1358
1359
1360
1361	//clear the mix buffer once
1362	m_pRoot->getRenderSystem()->_setViewport(renderTexture_DfShMix->getViewport(0)) ;
1363	m_pRoot->getRenderSystem()->clearFrameBuffer(FBT_COLOUR\|FBT_DEPTH, Ogre::ColourValue(0,0,0,1)) ;
1364
1365	// remove all the nodes
1366	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ; // remove all the objects
1367
1368	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1369	//
1370	// deferred shading non-shadowing point lights
1371	//
1372	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1373
1374
1375
1376	if(true)
1377	{
1378	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_LAMP) ; // attach the lamp boxes
1379
1380	// this renders our deferred shader lamps
1381	renderTexture_DfShLamp->update(true) ;
1382
1383	// this shader combines the deferred light render with the emissive render and colours it with any gels
1384	miniScreen_DfShMaster->setMaterial("Mix_Lamps") ;
1385
1386	// get rid of all the scene geometry
1387	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1388
1389	// put up a fullscreen quad so DfShMix has some UV coordinates.
1390	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMaster) ;
1391
1392	// update DfShMix, but don't swap buffers yet since we may be back again next loop with more lights to add.
1393	renderTexture_DfShMix->update(false) ;
1394
1395	// now DfShMix has all the deferred render stuff mixed onto it, as well as emissive stuff,
1396	// and it's ready for forward rendered shadowing lights to be additively blended over it.
1397	} // end if deferred render active
1398
1399
1400
1401
1402
1403	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1404	//
1405	// forward rendered shadowing spotlights
1406	//
1407	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1408
1409	// we now add entities from m_pVisibleEntity instead of m_pFrustumEntity since entities outside the frustum might still contribute shadows.
1410	//''
1411	if(true)
1412	{
1413
1414
1415	// multiple attempts at getting additive blending of the shadows failed, so I have to do an extra pass to "accumulate" the data :(
1416
1417	int nMaxVisibleLight=*m_pGlobal_MaxVisibleLight ;
1418
1419	// the texture view projection per light. We use four Vector4 instead of a single Matrix4 because we have to pass them to the shaders as custom params
1420	Ogre::Vector4 tvpMat0 ;
1421	Ogre::Vector4 tvpMat1 ;
1422	Ogre::Vector4 tvpMat2 ;
1423	Ogre::Vector4 tvpMat3 ;
1424
1425
1426
1427	int nVisibleLight=0 ;
1428	int nLt=0 ;
1429	int nProjector=0 ;
1430	int nEntLtIndex=0 ;
1431	int nEntLtIndexMax=0 ;
1432
1433	m_nVisibleLightCount=0 ; // total shadow lights added from all loops
1434
1435
1436	miniScreen_DfShMaster->setMaterial("Mix_ShadowLights") ;
1437
1438
1439	// loop through shadow casting lights
1440	for(nVisibleLight=0 ; nVisibleLight<nMaxVisibleLight ; nVisibleLight++)
1441	{
1442	// copy the camera's original settings because we'll be modifying it
1443	m_pCameraCopy->synchroniseBaseSettingsWith(m_pCamera) ;
1444
1445	nLt=m_pGlobal_VisibleLightList[nVisibleLight] ;
1446
1447	// setup the light and light's shadow camera, skip if light isn't really visible
1448	if(SetupSingleVisibleLightAndShadowCamera(nLt, m_pGlobal_LightVis, m_pGlobal_VisibleLightList, m_pCamera))
1449	{
1450	// count the light
1451	m_nVisibleLightCount++ ;
1452
1453
1454
1455
1456	/////////////////////////////////////////////////////////////////////////////////////////////////////
1457	// Render the shadow map
1458
1459	// add all the opaque stuff
1460	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1461	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_OPAQUE) ;
1462
1463
1464	for(nVisEnt=0 ; nVisEnt<m_nMaxVisibleEntity ; nVisEnt++)
1465	{
1466	// check if this entity touches this light
1467	nEntity=m_pVisibleEntity[nVisEnt] ;
1468
1469	m_pSceneMgr->getRootSceneNode()->addChild(m_pEntityInfo[ nEntity ].pMasterNode) ;
1470
1471	nEntLtIndexMax=m_pEntityInfo[nEntity].Light[INDEX_LIGHTPERENTITY] ;
1472	m_pEntityInfo[nEntity].LightTouch=0 ; // default, doesn't touch this light, use black material
1473	for(nEntLtIndex=0 ; nEntLtIndex<nEntLtIndexMax ; nEntLtIndex++)
1474	if(m_pEntityInfo[nEntity].Light[nEntLtIndex]==nLt) // found a match, entity is touched by this light
1475	{
1476	m_pEntityInfo[nEntity].LightTouch=1 ; // touches this light, don't use black
1477	break ;
1478	}
1479
1480	}// end for nVisEnt
1481
1482
1483
1484
1485
1486
1487
1488	// change to shadow pass material
1489	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1490	{
1491	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1492	nZGStart = m_nZoneMOStart[nZone] ;
1493	nZGEnd = m_nZoneMOStart[nZone+1] ;
1494
1495	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1496	if(m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE)
1497	{
1498	pEntity=m_pZoneEntity[nMO] ;
1499	pEntity->setMaterial( m_pZoneEntityMaterial_Shadow[nMO] ) ;
1500	}// end for entities
1501
1502	}// end for zonelist
1503
1504	for(nVisEnt=0 ; nVisEnt<m_nMaxVisibleEntity ; nVisEnt++)
1505	{
1506	nEntity=m_pVisibleEntity[nVisEnt] ;
1507	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1508
1509	// set the entity material
1510	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1511	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE)
1512	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_Shadow[nSubMesh] ) ;
1513	else
1514	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(false) ; // non-opaque stuff is invisible
1515	}
1516
1517
1518	// render the shadow map out to the Shadow texture
1519	renderTexture_Shadow->update(true) ;
1520
1521	// Opaque nodes are already in the scene, add all the Transparent stuff
1522	SetZoneNodeAttachments(m_uVisibleZoneListL, &m_nMaxVisibleZoneL, MAT_GEL) ;
1523
1524	// if this light is flagged as needing colourized shadows, we do the slower shadow method
1525	// this means rendering an extra couple of coloured shadow maps here, plus a different material for the view render
1526	if(m_nColouredShadow)
1527	{
1528
1529	/////////////////////////////////////////////////////////////////////////////////////////////////////
1530	// Render the ShadeFront map
1531
1532
1533
1534	// change to shadow pass material
1535	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1536	{
1537	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1538	nZGStart = m_nZoneMOStart[nZone] ;
1539	nZGEnd = m_nZoneMOStart[nZone+1] ;
1540
1541	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1542	if((m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE) \|\| (m_pZoneEntityMaterialType[nMO]==MAT_GEL))
1543	{
1544	pEntity=m_pZoneEntity[nMO] ;
1545	pEntity->setMaterial( m_pZoneEntityMaterial_ShadeFront[nMO] ) ;
1546	}// end for entities
1547
1548	}// end for zonelist
1549
1550	for(nVisEnt=0 ; nVisEnt<m_nMaxVisibleEntity ; nVisEnt++)
1551	{
1552	nEntity=m_pVisibleEntity[nVisEnt] ;
1553	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1554
1555	// set the entity material (pClearMaterial is already set)
1556	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1557	if((m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE) \|\| (m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GEL))
1558	{
1559	// make gel stuff visible
1560	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GEL)
1561	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setVisible(true) ;
1562
1563	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_ShadeFront[nSubMesh] ) ;
1564	}
1565	}
1566
1567	// render the shadow map out to the Shadow texture
1568	renderTexture_ShadeFront->update(true) ;
1569
1570
1571	/////////////////////////////////////////////////////////////////////////////////////////////////////
1572	// Render the ShadeBack map
1573
1574	// change to shadow pass material
1575	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1576	{
1577	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1578	nZGStart = m_nZoneMOStart[nZone] ;
1579	nZGEnd = m_nZoneMOStart[nZone+1] ;
1580
1581	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1582	if((m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE) \|\| (m_pZoneEntityMaterialType[nMO]==MAT_GEL))
1583	{
1584	pEntity=m_pZoneEntity[nMO] ;
1585	pEntity->setMaterial( m_pZoneEntityMaterial_ShadeBack[nMO] ) ;
1586	}// end for entities
1587
1588	}// end for zonelist
1589
1590	for(nVisEnt=0 ; nVisEnt<m_nMaxVisibleEntity ; nVisEnt++)
1591	{
1592	nEntity=m_pVisibleEntity[nVisEnt] ;
1593	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1594
1595	// set the entity material (pClearMaterial is already set)
1596	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1597	if((m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE) \|\| (m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GEL))
1598	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_ShadeBack[nSubMesh] ) ;
1599	}
1600
1601	// render the shadow map out to the Shadow texture
1602	renderTexture_ShadeBack->update(true) ;
1603
1604	} // end if we need coloured shadows
1605
1606
1607
1608
1609
1610
1611
1612	/////////////////////////////////////////////////////////////////////////////////////////////////////
1613	// Apply the shadow map to the view
1614
1615	// calculate the texture view projection matrix for this light
1616	Matrix4 TexViewProj=CreateTextureViewProjectionMatrix(m_pCamera) ;
1617
1618	// change the matrix to four Vector4s so we can pass it in as a shader parameter
1619	tvpMat0[0]=TexViewProj[0][0] ; tvpMat0[1]=TexViewProj[0][1] ; tvpMat0[2]=TexViewProj[0][2] ; tvpMat0[3]=TexViewProj[0][3] ;
1620	tvpMat1[0]=TexViewProj[1][0] ; tvpMat1[1]=TexViewProj[1][1] ; tvpMat1[2]=TexViewProj[1][2] ; tvpMat1[3]=TexViewProj[1][3] ;
1621	tvpMat2[0]=TexViewProj[2][0] ; tvpMat2[1]=TexViewProj[2][1] ; tvpMat2[2]=TexViewProj[2][2] ; tvpMat2[3]=TexViewProj[2][3] ;
1622	tvpMat3[0]=TexViewProj[3][0] ; tvpMat3[1]=TexViewProj[3][1] ; tvpMat3[2]=TexViewProj[3][2] ; tvpMat3[3]=TexViewProj[3][3] ;
1623
1624	// put the camera back to its proper position and settings.
1625	m_pCamera->synchroniseBaseSettingsWith(m_pCameraCopy) ;
1626	m_pCamera->setFOVy( Degree(m_flFOV) ) ;
1627	m_pCamera->setAspectRatio( Real(m_flAspectRatio) );
1628
1629
1630	nProjector=m_Q3Map->m_pLight[nLt].Texture ; // what projector texture is this light using?
1631
1632	// change material and set all the tvp custom params
1633	for(nZoneList=0 ; nZoneList<nMaxVisibleZone ; nZoneList++)
1634	{
1635	nZone=m_pGlobal_VisibleZoneList[nZoneList] ;
1636	nZGStart = m_nZoneMOStart[nZone] ;
1637	nZGEnd = m_nZoneMOStart[nZone+1] ;
1638
1639	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
1640	if((m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE) \|\| (m_pZoneEntityMaterialType[nMO]==MAT_GEL))
1641	{
1642	pEntity=m_pZoneEntity[nMO] ;
1643
1644
1645	// since the spot light pass is one of the slowest, we set the material of all the zones that don't touch
1646	// this light to just a black material. Only the zone of this light gets the real lighting material
1647	// We need to have the other zones though or we end up seeing through walls.
1648	// ALSO don't set gels to black, or else they block out the light in other zones.
1649
1650
1651	if((m_pZoneEntityMaterialType[nMO]==MAT_GEL) \|\| (LightTouchesZone(nLt, nZone)) )
1652	{
1653	if(m_nColouredShadow)
1654	pEntity->setMaterial( m_pZoneEntityMaterial_Base[nProjector][nMO] ) ; // coloured shadows
1655	else
1656	pEntity->setMaterial( m_pZoneEntityMaterial_Fast[nProjector][nMO] ) ; // fast shadows
1657	}
1658	else
1659	pEntity->setMaterial( m_pZoneEntityMaterial_Black[nMO] ) ; // just flat black, alpha tested for some
1660
1661
1662
1663
1664
1665	// set the custom parameter, our texture view projection matrix for this light
1666	pEntity->getSubEntity(0)->setCustomParameter(0, tvpMat0) ;
1667	pEntity->getSubEntity(0)->setCustomParameter(1, tvpMat1) ;
1668	pEntity->getSubEntity(0)->setCustomParameter(2, tvpMat2) ;
1669	pEntity->getSubEntity(0)->setCustomParameter(3, tvpMat3) ;
1670
1671	pEntity->getSubEntity(0)->setCustomParameter(4, TexParam) ;
1672
1673	}// end for entities
1674
1675	}// end for zonelist
1676
1677	for(nVisEnt=0 ; nVisEnt<m_nMaxVisibleEntity ; nVisEnt++)
1678	{
1679	nEntity=m_pVisibleEntity[nVisEnt] ;
1680	nMaxSubMesh=m_pEntityInfo[nEntity].MaxSubMesh ;
1681
1682	// set the entity material
1683	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
1684	if((m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_OPAQUE) \|\| (m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GEL))
1685	{
1686
1687	// if it's gel or the light touches the entity, use proper material, else use black
1688	if((m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GEL) \|\| m_pEntityInfo[nEntity].LightTouch)
1689	{
1690	if(m_nColouredShadow)
1691	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_Base[nProjector][nSubMesh] ) ; // coloured shadows
1692	else
1693	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_Fast[nProjector][nSubMesh] ) ; // fast shadows
1694	}
1695	else
1696	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( m_pEntityInfo[nEntity].Material_Black[nSubMesh] ) ; // flat black
1697
1698
1699
1700	// set the custom parameter, our texture view projection matrix for this light
1701	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setCustomParameter(0, tvpMat0) ;
1702	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setCustomParameter(1, tvpMat1) ;
1703	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setCustomParameter(2, tvpMat2) ;
1704	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setCustomParameter(3, tvpMat3) ;
1705
1706	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setCustomParameter(4, TexParam) ;
1707	}
1708	else
1709	m_pEntityInfo[nEntity].pEnt->getSubEntity(nSubMesh)->setMaterial( pClearMaterial ) ;
1710	}
1711
1712
1713
1714
1715	// if this is the first visible light, add emmissive transparent/alphablend particles.
1716	// they are added here so that they render correctly according to gels.
1717	// But since they aren't shadowed, we only need render them for one light.
1718	if(m_nVisibleLightCount==1)
1719	m_pSceneMgr->getRootSceneNode()->addChild(m_pParticleNode) ; // attach the particles
1720
1721
1722
1723	/////////////////////////////////////////////////////////////////////////////////////////////
1724	// render the scene out to the DfShTemp texture.
1725	//
1726
1727	renderTexture_DfShTemp->update(true) ;
1728
1729	//
1730	/////////////////////////////////////////////////////////////////////////////////////////////
1731
1732
1733
1734	// remove the particles
1735	if(m_nVisibleLightCount==1)
1736	m_pSceneMgr->getRootSceneNode()->removeChild(m_pParticleNode) ;
1737
1738
1739	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1740	// Render Mix
1741
1742	//?? unfortunately Ogre shares depth buffers in a manner that won't allow us to just additively render to DfShMix.
1743	// If we try, we get glitching from the buffer sharing between Shadow and DfShMix.
1744	// So instead we get rid of all geometry and additively render a fullscreen quad of DfShTemp to DfShMix.
1745	// Slows things down a little, but at least it works.
1746
1747	// get rid of all the scene geometry
1748	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1749
1750	// put up a fullscreen quad so DfShMix has some UV coordinates.
1751	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMaster) ;
1752
1753	// update DfShMix, but don't swap buffers yet since we may be back again next loop with more lights to add.
1754	renderTexture_DfShMix->update(false) ;
1755
1756	}// end if light is visible
1757
1758
1759	}// end for nVisibleLight
1760
1761	}// end if forward render active
1762
1763	///////////////////////////////////////////////////////////////////////////////////////
1764
1765
1766
1767	// after we've finished with all the lights and mixing, time to swap the mix buffer
1768	renderTexture_DfShMix->swapBuffers(false) ;
1769
1770
1771	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1772	//
1773	// HDR bloom
1774	//
1775	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1776
1777	if(m_nRenderHDR)
1778	{
1779	/////////////////////////////////////////////////////////
1780	// copy DfShMix to BlurA
1781
1782	// get rid of all the scene geometry
1783	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1784
1785	// this shader renders DfShMix onto a surface
1786	miniScreen_DfShMaster->setMaterial("HDR_MixToBlurA") ;
1787
1788	// put up a fullscreen quad so BlurA has some UV coordinates.
1789	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMaster) ;
1790
1791	// render DfShMix to BlurA
1792	renderTexture_BlurA->update(true) ;
1793
1794
1795
1796
1797	//////////////////////////////////////////////////////////////
1798	// now we do a few rounds of ping-pong bluring of A to B, B to A.
1799	int nMaxBlur=4 ;
1800	// int nLastBlur=nMaxBlur-1 ;
1801	int nBlurLoop=0 ;
1802
1803
1804	// opengl and direct3d give different results for the same blur shader,
1805	// the issue is that d3d with bilinear filtering will offset stuff,
1806	// leading to a right-down drift that we need to compensate for.
1807	// So we need two versions of the blur shaders, one for ogl and one for d3d.
1808
1809	if(m_IsOpenGL)
1810	{
1811	miniScreen_BlurA->setMaterial("HDR_BlurA_ogl");
1812	miniScreen_BlurB->setMaterial("HDR_BlurB_ogl");
1813	}
1814	else
1815	{
1816	miniScreen_BlurA->setMaterial("HDR_BlurA_d3d");
1817	miniScreen_BlurB->setMaterial("HDR_BlurB_d3d");
1818	}
1819
1820
1821	// the main blur
1822	for(nBlurLoop=0 ; nBlurLoop<nMaxBlur ; nBlurLoop++)
1823	{
1824	// blur A onto B
1825	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1826	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_BlurA) ;
1827	renderTexture_BlurB->update(true) ;
1828
1829	// blur B onto A
1830	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1831	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_BlurB) ;
1832	renderTexture_BlurA->update(true) ;
1833	}
1834
1835
1836	// If I don't set these materials back to their originals, I get a crash on exit.
1837	// Not sure why. Something to do with deleting the originals?
1838	// Doesn't matter, this fixes things.
1839
1840	miniScreen_BlurA->setMaterial("RttMat_BlurA");
1841	miniScreen_BlurB->setMaterial("RttMat_BlurB");
1842
1843
1844
1845	//////////////////////////////////////////////////////////////////
1846	// blend BlurA onto DfShMix
1847
1848	// get rid of all the scene geometry
1849	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1850
1851	// this shader blends BlurA onto a surface
1852	if(m_IsOpenGL)
1853	miniScreen_DfShMaster->setMaterial("HDR_BlurAToMix_ogl") ;
1854	else
1855	miniScreen_DfShMaster->setMaterial("HDR_BlurAToMix_d3d") ;
1856
1857	// put up a fullscreen quad so DfShMix has some UV coordinates.
1858	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMaster) ;
1859
1860	// update DfShMix.
1861	renderTexture_DfShMix->update(true) ;
1862
1863	}// end if HDR
1864
1865
1866	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1867	//
1868	// display a rendered window
1869	//
1870	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
1871
1872
1873	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ; // remove all the objects
1874
1875
1876	if(m_nGoggleMode==GOGGLE_MODE_OFF) // stereo rendering not active
1877	{
1878	switch(m_nDisplayInfoMode)
1879	{
1880
1881	case 0: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMix) ; break ;
1882	case 1: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShTemp) ; break ; // for wireframe view
1883	case 2: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShLamp) ; break ;
1884	case 3: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_BlurA) ; break ;
1885
1886	case 4: // instead of showing the original position texture, we show a scaled version, since the original is outside 0-1 range
1887
1888	// get rid of all the scene geometry
1889	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1890
1891	// this shader renders DfShMix onto a surface
1892	miniScreen_DfShMaster->setMaterial("Mix_ScalePosition") ;
1893
1894	// put up a fullscreen quad so BlurA has some UV coordinates.
1895	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMaster) ;
1896
1897	// render DfShPostion to DfShMix
1898	renderTexture_DfShMix->update(true) ;
1899
1900	// display mix, which is a scaled copy of position.
1901	m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMix) ;
1902	break ;
1903
1904	case 5: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShFuncTNB) ; break ;
1905	case 6: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShDiffuse) ; break ;
1906	case 7: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShSpecular) ; break ;
1907	case 8: m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShEmissive) ; break ;
1908	}
1909
1910
1911
1912
1913
1914	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShPosition) ;
1915	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShFuncTNB) ;
1916	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShSpecular) ;
1917	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShDiffuse) ;
1918	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShEmissive) ;
1919	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShData) ;
1920	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShLamp) ;
1921
1922	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_BlurA) ;
1923
1924	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShMix) ;
1925
1926	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_Shadow) ;
1927	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShTemp) ;
1928	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_ShadeBack) ;
1929	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_ShadeFront) ;
1930	}
1931	else
1932	{
1933	// add and position the Goggles
1934	m_pSceneMgr->getRootSceneNode()->addChild(m_pNodeGoggles) ;
1935	m_pNodeGoggles->setOrientation( m_pCamera->getOrientation() ) ;
1936	m_pNodeGoggles->setPosition( m_pCamera->getPosition() ) ;
1937	}
1938
1939
1940	//m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1941	//m_pSceneMgr->getRootSceneNode()->addChild(miniScreenNode_DfShDiffuse) ;
1942
1943
1944	m_pRenderWnd->update(true) ;
1945
1946
1947	//m_pSceneMgr->getRootSceneNode()->removeChild(miniScreenNode_DfShSpecular) ;
1948	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
1949
1950
1951
1952
1953	///////////////////////////////////////////
1954	// blittomemory experiment
1955	//uchar pixelData[64] ;
1956	//RTT_Texture_DfShPosition->getBuffer()->blitToMemory( Box( 0, 0, 1, 1), PixelBox(2, 2, 1, PF_FLOAT16_RGB, (void*)pixelData) ) ;
1957
1958
1959	}
1960
1961	// generate the texture view Projection matrix used in shadow mapping
1962	Ogre::Matrix4 OgreFramework::CreateTextureViewProjectionMatrix(Ogre::Camera* pCamera)
1963	{
1964
1965	const Matrix4 PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE(
1966	0.5, 0, 0, 0.5,
1967	0, -0.5, 0, 0.5,
1968	0, 0, 1, 0,
1969	0, 0, 0, 1);
1970
1971	Matrix4 TexViewProj = PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE * pCamera->getProjectionMatrixWithRSDepth() * pCamera->getViewMatrix();
1972
1973	return TexViewProj ;
1974
1975	}
1976
1977	void OgreFramework::DestroyGoggles()
1978	{
1979	//m_pGoggleL->~ManualObject() ;
1980	//m_pGoggleR->~ManualObject() ;
1981
1982	//m_pNodeGoggles->~SceneNode() ;
1983
1984
1985	}
1986
1987	// create the "virtual" virtual reality goggles we use to get around stereoscopic driver problems.
1988	int OgreFramework::CreateGoggles()
1989	{
1990
1991
1992	float flMinX=0.0f ;
1993	float flMinY=0.0f ;
1994	float flMaxX=0.0f ;
1995	float flMaxY=0.0f ;
1996
1997
1998	// if they already exist, destroy them so we can recreate them
1999	if(m_pNodeGoggles!=NULL) m_pNodeGoggles->detachAllObjects() ;
2000	if(m_pGoggleL!=NULL) m_pGoggleL->clear() ;
2001	if(m_pGoggleR!=NULL) m_pGoggleR->clear() ;
2002
2003
2004	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2005
2006	// left goggle
2007
2008	if(m_pGoggleL==NULL) m_pGoggleL=m_pSceneMgr->createManualObject("GoggleL") ;
2009	m_pGoggleL->begin("RttMat_DfShMix", RenderOperation::OT_TRIANGLE_LIST) ;
2010
2011	flMinX=-100m_flGoggleAspectRatiom_flGoggleXScale ;
2012	flMinY=-50*m_flGoggleYScale ;
2013
2014
2015	flMaxX=0 ;
2016	flMaxY=50*m_flGoggleYScale ;
2017
2018
2019	m_pGoggleL->position(flMinX-m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2020	m_pGoggleL->normal(0.0, 0.0, -1) ;
2021	m_pGoggleL->textureCoord(0.0, 0.0) ;
2022	m_pGoggleL->position(flMaxX-m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2023	m_pGoggleL->normal(0.0, 0.0, -1) ;
2024	m_pGoggleL->textureCoord(1.0, 0.0) ;
2025	m_pGoggleL->position(flMaxX-m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2026	m_pGoggleL->normal(0.0, 0.0, -1) ;
2027	m_pGoggleL->textureCoord(1.0, 1.0) ;
2028	m_pGoggleL->position(flMinX-m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2029	m_pGoggleL->normal(0.0, 0.0, -1) ;
2030	m_pGoggleL->textureCoord(0.0, 1.0) ;
2031
2032	m_pGoggleL->quad(3, 2, 1, 0) ;
2033	m_pGoggleL->end() ;
2034
2035	m_pGoggleL->setCastShadows(false) ;
2036
2037	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2038
2039	// right goggle
2040
2041	if(m_pGoggleR==NULL) m_pGoggleR=m_pSceneMgr->createManualObject("GoggleR") ;
2042	m_pGoggleR->begin("RttMat_DfShMix", RenderOperation::OT_TRIANGLE_LIST) ;
2043
2044
2045	flMinX=0 ;
2046	flMinY=-50*m_flGoggleYScale ;
2047
2048
2049	flMaxX=100m_flGoggleAspectRatiom_flGoggleXScale ;
2050	flMaxY=50*m_flGoggleYScale ;
2051
2052
2053	m_pGoggleR->position(flMinX+m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2054	m_pGoggleR->normal(0.0, 0.0, -1) ;
2055	m_pGoggleR->textureCoord(0.0, 0.0) ;
2056	m_pGoggleR->position(flMaxX+m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2057	m_pGoggleR->normal(0.0, 0.0, -1) ;
2058	m_pGoggleR->textureCoord(1.0, 0.0) ;
2059	m_pGoggleR->position(flMaxX+m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2060	m_pGoggleR->normal(0.0, 0.0, -1) ;
2061	m_pGoggleR->textureCoord(1.0, 1.0) ;
2062	m_pGoggleR->position(flMinX+m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2063	m_pGoggleR->normal(0.0, 0.0, -1) ;
2064	m_pGoggleR->textureCoord(0.0, 1.0) ;
2065
2066	m_pGoggleR->quad(3, 2, 1, 0) ;
2067	m_pGoggleR->end() ;
2068
2069	m_pGoggleR->setCastShadows(false) ;
2070
2071	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2072
2073	// attach the goggles to the node.
2074	if(m_pNodeGoggles==NULL) m_pNodeGoggles=m_pSceneMgr->getRootSceneNode()->createChildSceneNode("NodeGoggles") ;
2075	m_pNodeGoggles->attachObject(m_pGoggleL) ;
2076	m_pNodeGoggles->attachObject(m_pGoggleR) ;
2077
2078	return 1 ;
2079	}
2080
2081	// create the "virtual" virtual reality goggles we use to get around stereoscopic driver problems.
2082	// This version of the goggles just has a test image for setting up the correct real driver settings,
2083	// so that the left eye sees only the left "goggle" and the right eye only the right "goggle",
2084	// and the goggles have the right depth relative to the screen (flat to it)
2085	int OgreFramework::CreateGogglesTestImage()
2086	{
2087
2088	float flMinX=0.0f ;
2089	float flMinY=0.0f ;
2090	float flMaxX=0.0f ;
2091	float flMaxY=0.0f ;
2092
2093
2094	// if they already exist, destroy them so we can recreate them
2095	if(m_pNodeGoggles!=NULL) m_pNodeGoggles->detachAllObjects() ;
2096	if(m_pGoggleL!=NULL) m_pGoggleL->clear() ;
2097	if(m_pGoggleR!=NULL) m_pGoggleR->clear() ;
2098
2099
2100	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2101
2102	// left goggle
2103
2104	if(m_pGoggleL==NULL) m_pGoggleL=m_pSceneMgr->createManualObject("GoggleL") ;
2105	m_pGoggleL->begin("GoggleTest", RenderOperation::OT_TRIANGLE_LIST) ;
2106
2107	flMinX=-100m_flGoggleAspectRatiom_flGoggleXScale ;
2108	flMinY=-50*m_flGoggleYScale ;
2109
2110
2111	flMaxX=0 ;
2112	flMaxY=50*m_flGoggleYScale ;
2113
2114
2115	m_pGoggleL->position(flMinX-m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2116	m_pGoggleL->normal(0.0, 0.0, -1) ;
2117	m_pGoggleL->textureCoord(0.0, 0.0) ;
2118	m_pGoggleL->position(flMaxX-m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2119	m_pGoggleL->normal(0.0, 0.0, -1) ;
2120	m_pGoggleL->textureCoord(1.0, 0.0) ;
2121	m_pGoggleL->position(flMaxX-m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2122	m_pGoggleL->normal(0.0, 0.0, -1) ;
2123	m_pGoggleL->textureCoord(1.0, 1.0) ;
2124	m_pGoggleL->position(flMinX-m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2125	m_pGoggleL->normal(0.0, 0.0, -1) ;
2126	m_pGoggleL->textureCoord(0.0, 1.0) ;
2127
2128	m_pGoggleL->quad(3, 2, 1, 0) ;
2129	m_pGoggleL->end() ;
2130
2131	m_pGoggleL->setCastShadows(false) ;
2132
2133	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2134
2135	// right goggle
2136
2137	if(m_pGoggleR==NULL) m_pGoggleR=m_pSceneMgr->createManualObject("GoggleR") ;
2138	m_pGoggleR->begin("GoggleTest", RenderOperation::OT_TRIANGLE_LIST) ;
2139
2140
2141	flMinX=0 ;
2142	flMinY=-50*m_flGoggleYScale ;
2143
2144
2145	flMaxX=100m_flGoggleAspectRatiom_flGoggleXScale ;
2146	flMaxY=50*m_flGoggleYScale ;
2147
2148
2149	m_pGoggleR->position(flMinX+m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2150	m_pGoggleR->normal(0.0, 0.0, -1) ;
2151	m_pGoggleR->textureCoord(1.0, 1.0) ;
2152	m_pGoggleR->position(flMaxX+m_flGoggleXGap, flMaxY, m_flGoggleZPos) ;
2153	m_pGoggleR->normal(0.0, 0.0, -1) ;
2154	m_pGoggleR->textureCoord(0.0, 1.0) ;
2155	m_pGoggleR->position(flMaxX+m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2156	m_pGoggleR->normal(0.0, 0.0, -1) ;
2157	m_pGoggleR->textureCoord(0.0, 0.0) ;
2158	m_pGoggleR->position(flMinX+m_flGoggleXGap, flMinY, m_flGoggleZPos) ;
2159	m_pGoggleR->normal(0.0, 0.0, -1) ;
2160	m_pGoggleR->textureCoord(1.0, 0.0) ;
2161
2162	m_pGoggleR->quad(3, 2, 1, 0) ;
2163	m_pGoggleR->end() ;
2164
2165	m_pGoggleR->setCastShadows(false) ;
2166
2167	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2168
2169	// attach the goggles to the node.
2170	if(m_pNodeGoggles==NULL) m_pNodeGoggles=m_pSceneMgr->getRootSceneNode()->createChildSceneNode("NodeGoggles") ;
2171	m_pNodeGoggles->attachObject(m_pGoggleL) ;
2172	m_pNodeGoggles->attachObject(m_pGoggleR) ;
2173
2174	return 1 ;
2175	}
2176
2177	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2178
2179	bool OgreFramework::keyPressed(const OIS::KeyEvent &keyEventRef)
2180	{
2181	//m_pLog->logMessage("OgreFramework::keyPressed");
2182
2183	if(m_pKeyboard->isKeyDown(OIS::KC_ESCAPE))
2184	{
2185	m_bShutDownOgre = true;
2186	return true;
2187	}
2188
2189	if(m_pKeyboard->isKeyDown(OIS::KC_SYSRQ))
2190	{
2191	std::ostringstream ss;
2192	ss << "screenshot_" << ++m_iNumScreenShots << ".png";
2193	m_pRenderWnd->writeContentsToFile(ss.str());
2194	return true;
2195	}
2196
2197	/*
2198	if(m_pKeyboard->isKeyDown(OIS::KC_M))
2199	{
2200	static int mode = 0;
2201
2202	if(mode == 2)
2203	{
2204	m_pCamera->setPolygonMode(PM_SOLID);
2205	mode = 0;
2206	}
2207	else if(mode == 0)
2208	{
2209	m_pCamera->setPolygonMode(PM_WIREFRAME);
2210	mode = 1;
2211	}
2212	else if(mode == 1)
2213	{
2214	m_pCamera->setPolygonMode(PM_POINTS);
2215	mode = 2;
2216	}
2217	}
2218	*/
2219
2220	if(m_pKeyboard->isKeyDown(OIS::KC_O))
2221	{
2222	if(m_pDebugOverlay)
2223	{
2224	if(!m_pDebugOverlay->isVisible())
2225	m_pDebugOverlay->show();
2226	else
2227	m_pDebugOverlay->hide();
2228	}
2229	}
2230
2231
2232
2233	return true;
2234	}
2235
2236	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2237
2238	bool OgreFramework::keyReleased(const OIS::KeyEvent &keyEventRef)
2239	{
2240	return true;
2241	}
2242
2243	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2244
2245	bool OgreFramework::mouseMoved(const OIS::MouseEvent &evt)
2246	{
2247	m_pCamera->yaw(Degree(evt.state.X.rel * -0.1));
2248	m_pCamera->pitch(Degree(evt.state.Y.rel * -0.1));
2249
2250	return true;
2251	}
2252
2253	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2254
2255	bool OgreFramework::mousePressed(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
2256	{
2257	return true;
2258	}
2259
2260	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2261
2262	bool OgreFramework::mouseReleased(const OIS::MouseEvent &evt, OIS::MouseButtonID id)
2263	{
2264	return true;
2265	}
2266
2267	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2268
2269	void OgreFramework::updateOgre(double timeSinceLastFrame)
2270	{
2271
2272
2273
2274
2275	// update the game time
2276	m_GameTime+=timeSinceLastFrame ;
2277
2278
2279	m_MoveScale = m_MoveSpeed * timeSinceLastFrame;
2280	m_RotScale = m_RotateSpeed * timeSinceLastFrame;
2281
2282	m_TranslateVector = Vector3::ZERO;
2283
2284	// char chMessage[1024] ;
2285	//sprintf(chMessage, "winmessage %u, %u, %u", m_pRenderWnd->m_Test_uMsg, (UINT)m_pRenderWnd->m_Test_wParam, (UINT)m_pRenderWnd->m_Test_lParam) ;
2286	//m_pLog->logMessage(chMessage) ;
2287
2288
2289
2290	/*
2291	if((m_pRenderWnd->m_Test_uMsg==258) && (m_pRenderWnd->m_Test_wParam==0x78))
2292	//if(GetAsyncKeyState(0x78))
2293	{
2294
2295	m_TranslateVector.z = -m_MoveScale;
2296	//m_nGotInput=1 ;
2297
2298	//sprintf(chMessage, "T %i: winmessage %u, %u, %u", m_nTime, m_pRenderWnd->m_Test_uMsg, (UINT)m_pRenderWnd->m_Test_wParam, (UINT)m_pRenderWnd->m_Test_lParam) ;
2299	//m_pLog->logMessage(chMessage) ;
2300	}
2301	else
2302	m_nGotInput=0 ;
2303	*/
2304
2305	// add a test particle to the system
2306	/*
2307	if( m_ps->getNumParticles() < m_ps->getParticleQuota() )
2308	{
2309	Ogre::Particle *p = m_ps->createParticle() ;
2310	p->setDimensions( m_ps->getDefaultWidth(), m_ps->getDefaultHeight() ) ;
2311	p->colour = Ogre::ColourValue::White;
2312	p->direction = Ogre::Vector3::UNIT_Y;
2313	p->position = Ogre::Vector3::ZERO;
2314	p->timeToLive = p->totalTimeToLive = 10;
2315	p->rotation = Ogre::Radian(0);
2316	p->rotationSpeed = Ogre::Radian(0);
2317	}
2318	*/
2319
2320
2321	m_ps->_update(timeSinceLastFrame/1000.0f) ;
2322
2323	getInput();
2324
2325	moveCamera();
2326
2327
2328	//Ogre::Vector3 Pos ;
2329	//float CamPos[3] ;
2330	//Pos=m_pCamera->getPosition() ;
2331	//CamPos[0]=Pos.x ;
2332	//CamPos[1]=Pos.y ;
2333	//CamPos[2]=Pos.z ;
2334
2335
2336
2337	if(m_nGoggleMode==GOGGLE_MODE_OFF)
2338	{
2339
2340
2341	m_pCameraCopy->synchroniseBaseSettingsWith(m_pCamera) ; // copy the camera's original settings because we'll be modifying it for the LR views.
2342	m_pCameraCopy->setFOVy( Degree(m_flFOV) ) ;
2343	m_pCameraCopy->setAspectRatio( Real(m_flAspectRatio) );
2344
2345
2346
2347	if(m_nMapLoaded)
2348	{
2349	SetupEntityZones() ;
2350
2351	CalculateZoneVisibility(m_pCameraCopy, &m_nCameraZoneL, m_chZoneVisL, m_chLightVisL, m_chSubLightVisL, m_chPortalVisL, &m_nMaxVisibleLightL, m_uVisibleLightListL) ;
2352	CalculateEntityVisibility(m_pCameraCopy, m_chZoneVisL) ;
2353
2354	UpdateVisibleZoneList(m_chZoneVisL, m_uVisibleZoneListL, &m_nMaxVisibleZoneL) ;
2355
2356	//m_nVisibleLightCount=m_nMaxVisibleLightL ;
2357	m_nVisibleZoneCount=m_nMaxVisibleZoneL ;
2358	}
2359
2360
2361
2362	m_pGlobal_VisibleZoneList=m_uVisibleZoneListL ;
2363	m_pGlobal_MaxVisibleZone=&m_nMaxVisibleZoneL ;
2364
2365	m_pGlobal_VisibleLightList = m_uVisibleLightListL ;
2366	m_pGlobal_MaxVisibleLight = &m_nMaxVisibleLightL ;
2367	m_pGlobal_LightVis = m_chLightVisL ;
2368
2369
2370	}
2371	else
2372	{
2373	// "virtual" stereo goggle mode. Render everything twice, L and R view, and output to L quad and a R quad.
2374
2375	m_pCameraCopy->synchroniseBaseSettingsWith(m_pCamera) ; // copy the camera's original settings because we'll be modifying it for the LR views.
2376
2377	if(m_nMapLoaded)
2378	{
2379	SetupEntityZones() ;
2380
2381	CalculateZoneVisibility(m_pCameraCopy, &m_nCameraZoneL, m_chZoneVisL, m_chLightVisL, m_chSubLightVisL, m_chPortalVisL, &m_nMaxVisibleLightL, m_uVisibleLightListL) ;
2382	UpdateVisibleZoneList(m_chZoneVisL, m_uVisibleZoneListL, &m_nMaxVisibleZoneL) ;
2383
2384
2385	//m_nVisibleLightCount=m_nMaxVisibleLightL ;
2386	m_nVisibleZoneCount=m_nMaxVisibleZoneL ;
2387	}
2388
2389	m_pGlobal_VisibleZoneList=m_uVisibleZoneListL ;
2390	m_pGlobal_MaxVisibleZone=&m_nMaxVisibleZoneL ;
2391	}
2392
2393
2394	updateStats();
2395
2396
2397	//,,
2398	//sprintf(m_chFrame, "End of updateOgre frame %i",m_nFrame) ;
2399	//OFBug.LogAddCR(m_chFrame) ;
2400
2401
2402
2403	m_nFrame++ ;
2404
2405
2406
2407	}
2408
2409
2410
2411	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2412
2413	void OgreFramework::updateStats()
2414	{
2415
2416
2417	Ogre::Vector3 Pos ;
2418	Pos=m_pCamera->getPosition() ;
2419	Ogre::Real nCamX=Pos.x ;
2420	Ogre::Real nCamY=Pos.y ;
2421	Ogre::Real nCamZ=Pos.z ;
2422
2423
2424	static String currFps = "FPS: ";
2425	static String avgFps = "Av FPS: ";
2426	static String bestFps = "Best FPS: ";
2427	static String worstFps = "Worst FPS: ";
2428	static String tris = "Triangle Count: ";
2429	static String batches = "Batch Count: ";
2430
2431
2432	OverlayElement* guiAvg = OverlayManager::getSingleton().getOverlayElement("Core/AverageFps");
2433	OverlayElement* guiCurr = OverlayManager::getSingleton().getOverlayElement("Core/CurrFps");
2434	OverlayElement* guiBest = OverlayManager::getSingleton().getOverlayElement("Core/BestFps");
2435	OverlayElement* guiWorst = OverlayManager::getSingleton().getOverlayElement("Core/WorstFps");
2436
2437	const RenderTarget::FrameStats& stats = m_pRenderWnd->getStatistics();
2438
2439	//int LastFrameTime=1000000/stats.lastFPS ;
2440	float LastFrameTime=1000/stats.lastFPS ;
2441
2442
2443
2444
2445
2446	switch(m_nDisplayInfoMode)
2447	{
2448
2449	case 0:
2450	if(m_IsOpenGL)
2451	guiCurr->setCaption("OGL FPS: " + StringConverter::toString(stats.lastFPS) +" "+StringConverter::toString(LastFrameTime)+" ms");
2452	else
2453	guiCurr->setCaption("D3D FPS: " + StringConverter::toString(stats.lastFPS) +" "+StringConverter::toString(LastFrameTime)+" ms");
2454	break ;
2455
2456	case 1: guiCurr->setCaption("Wireframe") ; break ;
2457	case 2: guiCurr->setCaption("Lamps") ; break ;
2458	case 3: guiCurr->setCaption("HDR Blur") ; break ;
2459	case 4: guiCurr->setCaption("DefShade Position (Scaled)") ; break ;
2460	case 5: guiCurr->setCaption("DefShade Normals") ; break ;
2461	case 6: guiCurr->setCaption("DefShade Diffuse") ; break ;
2462	case 7: guiCurr->setCaption("DefShade Specular") ; break ;
2463	case 8: guiCurr->setCaption("DefShade Emissive") ; break ;
2464
2465	}
2466
2467	guiAvg->setCaption("Lt: " + StringConverter::toString(m_nVisibleLightCount)
2468	+ " Zn: " + StringConverter::toString(m_nVisibleZoneCount)
2469	+ " Cam: "+StringConverter::toString(nCamX)+" "+StringConverter::toString(nCamY)+" "+StringConverter::toString(nCamZ));
2470
2471
2472
2473
2474	//m_flDebug0=m_nTotalTriangles ;
2475	//m_flDebug1=m_nMaxVisibleEntity ;
2476	//m_flDebug2=m_nMaxFrustumEntity ;
2477	guiWorst->setCaption("ZnEnt: " + StringConverter::toString(m_nMaxVisibleEntity) + " Tri: " + StringConverter::toString(m_nVisibleEntityTriangleCount) + " FwdTri: " + StringConverter::toString(m_nVisibleEntityTriangleCount) ) ;
2478	guiBest->setCaption("FrEnt: " + StringConverter::toString(m_nMaxFrustumEntity) + " Tri: " + StringConverter::toString(m_nFrustumEntityTriangleCount) + " DefTri: " + StringConverter::toString(m_nFrustumEntityTriangleCount) ) ;
2479
2480
2481
2482
2483	//guiWorst->setCaption(StringConverter::toString(m_flDebug0) + " " + StringConverter::toString(m_flDebug1) + " " + StringConverter::toString(m_flDebug2)) ;
2484	//guiBest->setCaption(StringConverter::toString(m_flDebug3) + " " + StringConverter::toString(m_flDebug4) + " " + StringConverter::toString(m_flDebug5)) ;
2485	/*
2486	guiWorst->setCaption(
2487	" A "+StringConverter::toString(m_flDebugMatrix[0][0])+" "+StringConverter::toString(m_flDebugMatrix[0][1])+" "+StringConverter::toString(m_flDebugMatrix[0][2])+" "+StringConverter::toString(m_flDebugMatrix[0][3]) +
2488	" B "+StringConverter::toString(m_flDebugMatrix[1][0])+" "+StringConverter::toString(m_flDebugMatrix[1][1])+" "+StringConverter::toString(m_flDebugMatrix[1][2])+" "+StringConverter::toString(m_flDebugMatrix[1][3]) ) ;
2489
2490	guiBest->setCaption(
2491	" C "+StringConverter::toString(m_flDebugMatrix[2][0])+" "+StringConverter::toString(m_flDebugMatrix[2][1])+" "+StringConverter::toString(m_flDebugMatrix[2][2])+" "+StringConverter::toString(m_flDebugMatrix[2][3]) +
2492	" D "+StringConverter::toString(m_flDebugMatrix[3][0])+" "+StringConverter::toString(m_flDebugMatrix[3][1])+" "+StringConverter::toString(m_flDebugMatrix[3][2])+" "+StringConverter::toString(m_flDebugMatrix[3][3]) ) ;
2493	*/
2494
2495
2496
2497
2498	//guiWorst->setCaption(StringConverter::toString(flVarA)+" "+StringConverter::toString(flVarB)+" "+StringConverter::toString(flVarC)+" "+StringConverter::toString(flVarD)
2499
2500	//guiBest->setCaption(bestFps + StringConverter::toString(stats.bestFPS)
2501	// +" "+StringConverter::toString(stats.bestFrameTime)+" ms");
2502	//guiWorst->setCaption(worstFps + StringConverter::toString(stats.worstFPS)
2503	// +" "+StringConverter::toString(stats.worstFrameTime)+" ms");
2504
2505	//guiWorst->setCaption(worstFps + StringConverter::toString(nCamX)+" " + StringConverter::toString(nCamY)+" " + StringConverter::toString(nCamZ)+" ") ;
2506
2507
2508	OverlayElement* guiTris = OverlayManager::getSingleton().getOverlayElement("Core/NumTris");
2509	guiTris->setCaption("MpTri: " + StringConverter::toString(m_nTotalTriangles));
2510
2511	OverlayElement* guiBatches = OverlayManager::getSingleton().getOverlayElement("Core/NumBatches");
2512	guiBatches->setCaption(batches + StringConverter::toString(stats.batchCount));
2513
2514	OverlayElement* guiDbg = OverlayManager::getSingleton().getOverlayElement("Core/DebugText");
2515	guiDbg->setCaption("A:"+StringConverter::toString(m_nDebugA) + " B:" + StringConverter::toString(m_nDebugB) + " C:" + StringConverter::toString(m_nDebugC) + " ") ;
2516
2517	//guiDbg->setCaption(
2518	// " A "+StringConverter::toString(m_flDebugMatrix[0][0])+" "+StringConverter::toString(m_flDebugMatrix[0][1])+" "+StringConverter::toString(m_flDebugMatrix[0][2])+" "+StringConverter::toString(m_flDebugMatrix[0][3]) +
2519	// " B "+StringConverter::toString(m_flDebugMatrix[1][0])+" "+StringConverter::toString(m_flDebugMatrix[1][1])+" "+StringConverter::toString(m_flDebugMatrix[1][2])+" "+StringConverter::toString(m_flDebugMatrix[1][3]) +
2520	// " C "+StringConverter::toString(m_flDebugMatrix[2][0])+" "+StringConverter::toString(m_flDebugMatrix[2][1])+" "+StringConverter::toString(m_flDebugMatrix[2][2])+" "+StringConverter::toString(m_flDebugMatrix[2][3]) +
2521	// " D "+StringConverter::toString(m_flDebugMatrix[3][0])+" "+StringConverter::toString(m_flDebugMatrix[3][1])+" "+StringConverter::toString(m_flDebugMatrix[3][2])+" "+StringConverter::toString(m_flDebugMatrix[3][3]) ) ;
2522
2523
2524
2525
2526	//guiDbg->setCaption("");
2527	}
2528
2529	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2530
2531	void OgreFramework::moveCamera()
2532	{
2533	if( m_nKeyDown_Ctrl && m_nKeyDown_Shift ) // super slow
2534	m_pCamera->moveRelative(m_TranslateVector/50);
2535	else
2536	if(m_nKeyDown_Shift) // fast
2537	m_pCamera->moveRelative(m_TranslateVector*10);
2538	else
2539	if(m_nKeyDown_Ctrl) // slow
2540	m_pCamera->moveRelative(m_TranslateVector/5);
2541	else
2542	m_pCamera->moveRelative(m_TranslateVector*2); // normal
2543	}
2544
2545	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2546
2547	void OgreFramework::getInput()
2548	{
2549	if(m_pKeyboard->isKeyDown(OIS::KC_LCONTROL))
2550	m_nKeyDown_Ctrl=1 ;
2551	else
2552	m_nKeyDown_Ctrl=0 ;
2553
2554	if(m_pKeyboard->isKeyDown(OIS::KC_LSHIFT))
2555	m_nKeyDown_Shift=1 ;
2556	else
2557	m_nKeyDown_Shift=0 ;
2558
2559
2560
2561
2562
2563
2564	if(m_pKeyboard->isKeyDown(OIS::KC_A))
2565	{
2566	m_TranslateVector.x = -m_MoveScale;
2567	}
2568
2569	if(m_pKeyboard->isKeyDown(OIS::KC_D))
2570	{
2571	m_TranslateVector.x = m_MoveScale;
2572	}
2573
2574	if(m_pKeyboard->isKeyDown(OIS::KC_W))
2575	{
2576	m_TranslateVector.z = -m_MoveScale;
2577	m_nGotInput=1 ;
2578	}
2579
2580	if(m_pKeyboard->isKeyDown(OIS::KC_S))
2581	{
2582	m_TranslateVector.z = m_MoveScale;
2583	}
2584
2585
2586	// generic toggle for debugging
2587	if(m_pKeyboard->isKeyDown(OIS::KC_T))
2588	{
2589	if(m_nKeyToggle[OIS::KC_T]==0)
2590	{
2591	m_nKeyToggle[OIS::KC_T]=1 ; // toggle to stop key repeating
2592	m_nToggle=1-m_nToggle ;
2593	//OFBug.MessageInt(m_nToggle) ;
2594	}
2595	}
2596	else
2597	m_nKeyToggle[OIS::KC_T]=0 ;
2598
2599	//m_flDebug0=m_nKeyToggle[OIS::KC_T] ;
2600	//m_flDebug1=m_nToggle ;
2601
2602	/*
2603	if(m_pKeyboard->isKeyDown(OIS::KC_LEFT))
2604	{
2605	m_pCamera->yaw(m_RotScale);
2606	}
2607
2608	if(m_pKeyboard->isKeyDown(OIS::KC_RIGHT))
2609	{
2610	m_pCamera->yaw(-m_RotScale);
2611	}
2612
2613	if(m_pKeyboard->isKeyDown(OIS::KC_UP))
2614	{
2615	m_pCamera->pitch(m_RotScale);
2616	}
2617
2618	if(m_pKeyboard->isKeyDown(OIS::KC_DOWN))
2619	{
2620	m_pCamera->pitch(-m_RotScale);
2621	}
2622	*/
2623
2624	/////////////////////////////////////////////////////////////////////////////////////////////////////////
2625	//
2626	// Stereo controls
2627
2628
2629
2630	// toggle stereo test image mode
2631	if(m_pKeyboard->isKeyDown(OIS::KC_DELETE))
2632	{
2633	if(m_nKeyToggle[OIS::KC_DELETE]==0)
2634	{
2635	m_nKeyToggle[OIS::KC_DELETE]=1 ; // toggle to stop key repeating
2636
2637	m_nGoggleMode++ ; // cyle through the goggle modes
2638	if(m_nGoggleMode>=GOGGLE_MODE_MAX)
2639	m_nGoggleMode=GOGGLE_MODE_OFF ;
2640
2641	if(m_nGoggleMode==GOGGLE_MODE_TEST)
2642	CreateGogglesTestImage() ; // create the test goggles
2643	else
2644	if(m_nGoggleMode==GOGGLE_MODE_ON)
2645	CreateGoggles() ; // create the stereo goggles
2646	}
2647	}
2648	else
2649	m_nKeyToggle[OIS::KC_DELETE]=0 ;
2650
2651	if(m_nGoggleMode==GOGGLE_MODE_TEST) // controls for setting up the test image
2652	{
2653	int nDoPause=0 ; // if any control gets used we do a quick pause to make the rate of change a bit more consistent, not as frame-rate dependent
2654
2655	if(m_pKeyboard->isKeyDown(OIS::KC_PGUP))
2656	{
2657	nDoPause=1 ;
2658
2659	if(m_nKeyDown_Shift)
2660	m_flGoggleZPos-=1.0 ;
2661	else
2662	if(m_nKeyDown_Ctrl)
2663	m_flGoggleZPos-=0.01 ;
2664	else
2665	m_flGoggleZPos-=0.1 ;
2666
2667	CreateGogglesTestImage() ;
2668	}
2669
2670	if(m_pKeyboard->isKeyDown(OIS::KC_PGDOWN))
2671	{
2672	nDoPause=1 ;
2673
2674	if(m_nKeyDown_Shift)
2675	m_flGoggleZPos+=1.0 ;
2676	else
2677	if(m_nKeyDown_Ctrl)
2678	m_flGoggleZPos+=0.01 ;
2679	else
2680	m_flGoggleZPos+=0.1 ;
2681
2682	CreateGogglesTestImage() ;
2683	}
2684
2685	if(m_pKeyboard->isKeyDown(OIS::KC_HOME))
2686	{
2687	nDoPause=1 ;
2688
2689	if(m_nKeyDown_Shift)
2690	m_flGoggleXGap-=0.1 ;
2691	else
2692	if(m_nKeyDown_Ctrl)
2693	m_flGoggleXGap-=0.001 ;
2694	else
2695	m_flGoggleXGap-=0.01 ;
2696
2697	if(m_flGoggleXGap<0)
2698	m_flGoggleXGap=0 ;
2699
2700	CreateGogglesTestImage() ;
2701	}
2702
2703	if(m_pKeyboard->isKeyDown(OIS::KC_END))
2704	{
2705	nDoPause=1 ;
2706
2707	if(m_nKeyDown_Shift)
2708	m_flGoggleXGap+=0.1 ;
2709	else
2710	if(m_nKeyDown_Ctrl)
2711	m_flGoggleXGap+=0.001 ;
2712	else
2713	m_flGoggleXGap+=0.01 ;
2714
2715	if(m_flGoggleXGap<0)
2716	m_flGoggleXGap=0 ;
2717
2718	CreateGogglesTestImage() ;
2719	}
2720
2721	if(m_pKeyboard->isKeyDown(OIS::KC_UP))
2722	{
2723	nDoPause=1 ;
2724
2725	if(m_nKeyDown_Shift && m_nKeyDown_Ctrl)
2726	m_flGoggleYScale=1.0 ;
2727	else
2728	if(m_nKeyDown_Shift)
2729	m_flGoggleYScale+=0.002 ;
2730	else
2731	if(m_nKeyDown_Ctrl)
2732	m_flGoggleYScale+=0.00002 ;
2733	else
2734	m_flGoggleYScale+=0.0002 ;
2735
2736	if(m_flGoggleYScale<0)
2737	m_flGoggleYScale=0 ;
2738
2739	CreateGogglesTestImage() ;
2740	}
2741
2742	if(m_pKeyboard->isKeyDown(OIS::KC_DOWN))
2743	{
2744	nDoPause=1 ;
2745
2746	if(m_nKeyDown_Shift && m_nKeyDown_Ctrl)
2747	m_flGoggleYScale=1.0 ;
2748	else
2749	if(m_nKeyDown_Shift)
2750	m_flGoggleYScale-=0.002 ;
2751	else
2752	if(m_nKeyDown_Ctrl)
2753	m_flGoggleYScale-=0.00002 ;
2754	else
2755	m_flGoggleYScale-=0.0002 ;
2756
2757	if(m_flGoggleYScale<0)
2758	m_flGoggleYScale=0 ;
2759
2760	CreateGogglesTestImage() ;
2761	}
2762
2763	if(m_pKeyboard->isKeyDown(OIS::KC_LEFT))
2764	{
2765	nDoPause=1 ;
2766
2767	if(m_nKeyDown_Shift && m_nKeyDown_Ctrl)
2768	m_flGoggleXScale=1.0 ;
2769	else
2770	if(m_nKeyDown_Shift)
2771	m_flGoggleXScale+=0.002 ;
2772	else
2773	if(m_nKeyDown_Ctrl)
2774	m_flGoggleXScale+=0.00002 ;
2775	else
2776	m_flGoggleXScale+=0.0002 ;
2777
2778	if(m_flGoggleXScale<0)
2779	m_flGoggleXScale=0 ;
2780
2781	CreateGogglesTestImage() ;
2782	}
2783
2784	if(m_pKeyboard->isKeyDown(OIS::KC_RIGHT))
2785	{
2786	nDoPause=1 ;
2787
2788	if(m_nKeyDown_Shift && m_nKeyDown_Ctrl)
2789	m_flGoggleXScale=1.0 ;
2790	else
2791	if(m_nKeyDown_Shift)
2792	m_flGoggleXScale-=0.002 ;
2793	else
2794	if(m_nKeyDown_Ctrl)
2795	m_flGoggleXScale-=0.00002 ;
2796	else
2797	m_flGoggleXScale-=0.0002 ;
2798
2799	if(m_flGoggleXScale<0)
2800	m_flGoggleXScale=0 ;
2801
2802	CreateGogglesTestImage() ;
2803	}
2804
2805
2806
2807	if(nDoPause) Sleep(20) ; // pause makes rate more consisent, less frame rate dependent.
2808
2809	}// end test image controls
2810
2811
2812
2813	//
2814	//
2815	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2816
2817	// flashlight
2818	if(m_pKeyboard->isKeyDown(OIS::KC_F))
2819	{
2820	if(m_nKeyToggle[OIS::KC_F]==0)
2821	{
2822	m_nKeyToggle[OIS::KC_F]=1 ; // toggle to stop key repeating
2823	m_nFlashLight=1-m_nFlashLight ;
2824	m_nDebugA=m_nFlashLight ;
2825	//OFBug.MessageInt(m_nToggle) ;
2826	}
2827	}
2828	else
2829	m_nKeyToggle[OIS::KC_F]=0 ;
2830
2831
2832	if(m_pKeyboard->isKeyDown(OIS::KC_J))
2833	{
2834	if(m_nJumpToggle==0)
2835	{
2836	m_nJumpToggle=1 ;
2837
2838
2839	m_nJumpVal++ ;
2840	if(m_nJumpVal>=m_Q3Map->m_nLightMax)
2841	m_nJumpVal=0 ;
2842
2843	//m_flDebug0=m_nJumpVal ;
2844
2845
2846	//m_nJumpVal=12 ; // for now always jump to light 0
2847	//m_pCamera->setPosition(m_Q3Map->m_pLight[m_nJumpVal].Position[0], m_Q3Map->m_pLight[m_nJumpVal].Position[1], m_Q3Map->m_pLight[m_nJumpVal].Position[2]) ;
2848	//m_nJumpVal=13 ;
2849	//m_pCamera->lookAt(Vector3(m_Q3Map->m_pLight[m_nJumpVal].Position[0], m_Q3Map->m_pLight[m_nJumpVal].Position[1], m_Q3Map->m_pLight[m_nJumpVal].Position[2]));
2850
2851	//m_pCamera->setPosition(166, 222, -111) ;
2852	//m_pCamera->setDirection(0.707, 0, -0.707) ;
2853
2854	//m_pCamera->setPosition(m_Q3Map->m_pLight[0].Position[0], m_Q3Map->m_pLight[0].Position[1], m_Q3Map->m_pLight[0].Position[2]) ;
2855	//m_pCamera->setDirection(m_Q3Map->m_pLight[0].Direction[0], m_Q3Map->m_pLight[0].Direction[1], m_Q3Map->m_pLight[0].Direction[2]) ;
2856	//m_pCamera->setFOVy( Degree(m_Q3Map->m_pLight[0].Angle ) ) ;
2857
2858	//m_pCamera->setDirection(m_pLight[m_nJumpVal].Direction[0], m_pLight[m_nJumpVal].Direction[1], m_pLight[m_nJumpVal].Direction[2]) ;
2859	// 880 120 -340
2860	//m_pCamera->lookAt(Vector3(880,120,-340));
2861	//m_pCamera->lookAt(Vector3(915,155,-340));
2862
2863
2864	m_pCamera->setPosition(600, 200, -250) ;
2865	//m_pCamera->setDirection(1.0, 0.0, 0.0) ;
2866	m_pCamera->lookAt(700, 200, -450);
2867
2868
2869
2870	}
2871	}
2872	else
2873	m_nJumpToggle=0 ;
2874
2875
2876	if(m_pKeyboard->isKeyDown(OIS::KC_L))
2877	{
2878	if(m_nLoadToggle==0)
2879	{
2880	UnloadMap(false) ;
2881	nMap++ ;
2882	LoadMap() ;
2883	//m_nLoadToggle=1 ;
2884	}
2885	}
2886	else
2887	m_nLoadToggle=0 ;
2888
2889
2890	// generic toggle for debugging
2891	if(m_pKeyboard->isKeyDown(OIS::KC_M))
2892	{
2893	if(m_nKeyToggle[OIS::KC_M]==0)
2894	{
2895	m_nKeyToggle[OIS::KC_M]=1 ; // toggle to stop key repeating
2896
2897	m_nDisplayInfoMode++ ;
2898	if(m_nDisplayInfoMode==9)
2899	m_nDisplayInfoMode=0 ;
2900
2901
2902
2903	}
2904	}
2905	else
2906	m_nKeyToggle[OIS::KC_M]=0 ;
2907
2908
2909
2910
2911
2912	//if(m_pKeyboard->isKeyDown(OIS::KC_K)) m_nVideoRestart=1 ;
2913
2914
2915	if(m_pKeyboard->isKeyDown(OIS::KC_P))
2916	{
2917	if(m_nPortalToggle==0)
2918	{
2919	m_nPortalState=1-m_nPortalState ;
2920	m_nPortalToggle=1 ;
2921	}
2922	}
2923	else
2924	m_nPortalToggle=0 ;
2925
2926	if(m_pKeyboard->isKeyDown(OIS::KC_ESCAPE))
2927	{
2928	m_bShutDownOgre = true;
2929	}
2930
2931	}
2932
2933	//\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|\|
2934	//shutdown
2935	// the dynamic memory deletes are all safe, so it's ok to try and delete them even if they don't exist.
2936	void OgreFramework::UnloadMap(bool bShutdown)
2937	{
2938
2939	//if(!bShutdown) DestroyRTTAssets() ;
2940
2941	//if(ResourceGroupManager::getSingleton().isResourceGroupLoaded("Raw Bsp"))
2942	// ResourceGroupManager::getSingleton().clearResourceGroup("Raw Bsp") ;
2943
2944
2945	// only do if there was a definitely a map loaded.
2946	if(m_nMapLoaded)
2947	{
2948	char chSceneNodeName[1024] ;
2949	// make sure all the zone nodes are re-attached to the root node or they won't get deleted
2950	for(int nZone=0 ; nZone<m_Q3Map->m_nMaxZone ; nZone++)
2951	{
2952	// Opaque nodes
2953	if(m_nOpaqueNodeUsed[nZone]) // only do this if the node actually exists
2954	{
2955	if(!m_pOpaqueNode[nZone]->isInSceneGraph())
2956	m_pSceneMgr->getRootSceneNode()->addChild(m_pOpaqueNode[nZone]) ;
2957
2958	sprintf(chSceneNodeName, "Opaque%05i", nZone) ;
2959	m_pSceneMgr->getRootSceneNode()->removeAndDestroyChild(chSceneNodeName) ;
2960
2961	}
2962
2963	// Trans nodes
2964	if(m_nTransNodeUsed[nZone]) // only do this if the node actually exists
2965	{
2966	if(!m_pTransNode[nZone]->isInSceneGraph())
2967	m_pSceneMgr->getRootSceneNode()->addChild(m_pTransNode[nZone]) ;
2968
2969	sprintf(chSceneNodeName, "Trans%05i", nZone) ;
2970	m_pSceneMgr->getRootSceneNode()->removeAndDestroyChild(chSceneNodeName) ;
2971
2972	}
2973
2974	// Lamp nodes
2975	if(m_nLampNodeUsed[nZone]) // only do this if the node actually exists
2976	{
2977	if(!m_pLampNode[nZone]->isInSceneGraph())
2978	m_pSceneMgr->getRootSceneNode()->addChild(m_pLampNode[nZone]) ;
2979
2980	sprintf(chSceneNodeName, "Lamp%05i", nZone) ;
2981	m_pSceneMgr->getRootSceneNode()->removeAndDestroyChild(chSceneNodeName) ;
2982
2983	}
2984
2985	// Glow nodes
2986	if(m_nGlowNodeUsed[nZone]) // only do this if the node actually exists
2987	{
2988	if(!m_pGlowNode[nZone]->isInSceneGraph())
2989	m_pSceneMgr->getRootSceneNode()->addChild(m_pGlowNode[nZone]) ;
2990
2991	sprintf(chSceneNodeName, "Glow%05i", nZone) ;
2992	m_pSceneMgr->getRootSceneNode()->removeAndDestroyChild(chSceneNodeName) ;
2993
2994	}
2995
2996	}
2997
2998
2999	// reattach all entity scenenodes.
3000	int nLoop=0 ;
3001	// int nSubMesh=0 ;
3002	// int nMaxSubMesh=0 ;
3003	for(nLoop=0 ; nLoop<m_nMaxEntity ; nLoop++)
3004	m_pSceneMgr->getRootSceneNode()->addChild(m_pEntityInfo[nLoop].pMasterNode) ;
3005
3006	}// end if map loaded
3007
3008
3009	// free ogre stuff
3010	//Ogre::ResourceGroupManager::getSingleton().clearResourceGroup(ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME) ;
3011
3012	//Ogre::ResourcePtr RTT=Ogre::TextureManager::getSingleton().getByName("RttTex") ;
3013	//Ogre::TextureManager::getSingleton().remove(RTT) ;
3014
3015	//RTT_Texture->unload() ;
3016
3017
3018
3019
3020
3021
3022
3023	//m_pSceneMgr->clearScene() ;
3024	m_pSceneMgr->getRootSceneNode()->removeAndDestroyAllChildren() ; // destroy all scenenodes
3025
3026	m_pSceneMgr->destroyAllEntities() ;
3027	m_pSceneMgr->destroyAllLights() ;
3028	m_pSceneMgr->destroyAllManualObjects() ;
3029
3030
3031	/*
3032	// unload all the meshes
3033	int nMaxMesh=m_nZoneMOStart[m_Q3Map->m_nMaxZone] ;
3034	int nMesh=0 ;
3035	for(nMesh=0 ; nMesh<nMaxMesh ; nMesh++)
3036	{
3037	m_pSceneMgr->destroyEntity(m_pZoneEntity[nMesh]) ;
3038	//m_pZoneMesh[nMesh]->cleanupDictionary() ;
3039	//m_pZoneMesh[nMesh]->unload() ;
3040
3041
3042	}
3043	*/
3044
3045	MeshManager::getSingleton().removeAll() ; // this destroys all the meshes
3046
3047
3048
3049	//OFBug.MessageInt(333) ;
3050	//Ogre::TextureManager::getSingleton().unloadAll() ;
3051	//Ogre::TextureManager::getSingleton().removeAll() ;
3052
3053	//Ogre::MaterialManager::getSingleton().unloadAll() ;
3054	//Ogre::MaterialManager::getSingleton().removeAll() ;
3055
3056
3057
3058
3059
3060	//SetupResourceLocations() ;
3061
3062	// delete our array of Zone group manual objects
3063	//CHECKDELETE_ARRAY( m_pZoneMO ) ;
3064	CHECKDELETE_ARRAY( m_pZoneMesh, NEW_CHECK_m_pZoneMesh ) ;
3065	CHECKDELETE_ARRAY( m_pZoneEntity, NEW_CHECK_m_pZoneEntity ) ;
3066	CHECKDELETE_ARRAY( m_pZoneEntityMaterialType, NEW_CHECK_m_pZoneEntityMaterialType ) ;
3067
3068
3069	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Shadow, NEW_CHECK_m_pZoneEntityMaterial_Shadow ) ;
3070	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_ShadeFront, NEW_CHECK_m_pZoneEntityMaterial_ShadeFront ) ;
3071	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_ShadeBack, NEW_CHECK_m_pZoneEntityMaterial_ShadeBack ) ;
3072
3073	int nPTex=0 ;
3074	for(nPTex=0 ; nPTex<MAX_PROJECTORTEX ; nPTex++)
3075	{
3076	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Base[nPTex], NEW_CHECK_m_pZoneEntityMaterial_Base ) ;
3077	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Fast[nPTex], NEW_CHECK_m_pZoneEntityMaterial_Fast ) ;
3078	}
3079
3080	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Black, NEW_CHECK_m_pZoneEntityMaterial_Black ) ;
3081	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShColour, NEW_CHECK_m_pZoneEntityMaterial_DfShColour ) ;
3082	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShPosition, NEW_CHECK_m_pZoneEntityMaterial_DfShPosition ) ;
3083	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShDiffuse, NEW_CHECK_m_pZoneEntityMaterial_DfShDiffuse ) ;
3084	//CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DSNormal ) ;
3085	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShFuncTNB, NEW_CHECK_m_pZoneEntityMaterial_DfShFuncTNB ) ;
3086	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShSpecular, NEW_CHECK_m_pZoneEntityMaterial_DfShSpecular ) ;
3087	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShEmissive, NEW_CHECK_m_pZoneEntityMaterial_DfShEmissive ) ;
3088	//CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShData ) ;
3089	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShMix, NEW_CHECK_m_pZoneEntityMaterial_DfShMix ) ;
3090
3091	////////////////////////////////////////////////////////
3092	CHECKDELETE_ARRAY( m_pEntityInfo, NEW_CHECK_m_pEntityInfo ) ;
3093	CHECKDELETE_ARRAY( m_pVisibleEntity, NEW_CHECK_m_pVisibleEntity ) ;
3094	CHECKDELETE_ARRAY( m_pFrustumEntity, NEW_CHECK_m_pFrustumEntity ) ;
3095
3096
3097	// was leaking before, but this seems to have fixed things.
3098	Ogre::ResourceGroupManager::getSingleton().clearResourceGroup(ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME) ;
3099
3100	// delete our debug light manualobjects/zones
3101	// CHECKDELETE_ARRAY( m_pLightMO ) ;
3102
3103	// CHECKDELETE_ARRAY( m_pPortalMO ) ;
3104	// CHECKDELETE_ARRAY( m_pPortalNode ) ;
3105
3106	// free our dynamic memory
3107	if(m_Q3Map)
3108	{
3109	m_Q3Map->~Q3Map() ; // get rid of all the m_Q3Map stuff
3110	CHECKDELETE_POINTER( m_Q3Map, NEW_CHECK_m_Q3Map) ;
3111	m_Q3Map=NULL ;
3112	}
3113
3114	if(m_bRawBspFileIsLoaded)
3115	{
3116	//m_pRawBspFile->unload() ;
3117	CHECKDELETE_ARRAY(m_pRawBspFile, NEW_CHECK_m_pRawBspFile ) ;
3118	m_bRawBspFileIsLoaded=false ;
3119	}
3120
3121	// indicate that there is no map.
3122	m_nMapLoaded=0 ;
3123
3124
3125
3126
3127	int nCheck=0 ;
3128	for(nCheck=0 ; nCheck<MAX_NEW_CHECK ; nCheck++)
3129	if(m_nNewCheck[nCheck]!=0)
3130	{
3131	sprintf(m_chBug, "MEMORY LEAK: NewCheck %i, NewCount %i", nCheck, m_nNewCheck[nCheck]) ;
3132	m_pLog->logMessage(m_chBug) ;
3133	}
3134
3135
3136	//OFBug.MessageInt(333) ;
3137	//Sleep(50) ;
3138	}
3139
3140
3141
3142
3143
3144
3145
3146
3147	/***********************************************************************************************************\
3148
3149	LOAD MAP
3150
3151	\***********************************************************************************************************/
3152
3153
3154
3155
3156	int OgreFramework::LoadMap(void)
3157	{
3158	m_pLog->logMessage("LoadMap.") ;
3159
3160
3161
3162	ZeroMemory((void*)m_nKeyToggle, sizeof(m_nKeyToggle)) ; // good place to clear the keytoggle just in case
3163
3164	m_pLog->logMessage("Pre InitAllResourceGroups.") ;
3165	Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
3166	m_pLog->logMessage("Post InitAllResourceGroups.") ;
3167
3168	// setup the clear material
3169	pClearMaterial=MaterialManager::getSingleton().getByName("Clear") ;
3170
3171
3172	//CreateRTTAssets() ;
3173
3174
3175
3176	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3177
3178	m_pDebugOverlay = OverlayManager::getSingleton().getByName("Core/DebugOverlay");
3179	m_pDebugOverlay->show();
3180
3181	//m_MapName="test04e.bsp" ;
3182	//m_MapName="test04g.bsp" ;
3183	//m_MapName="test03f.bsp" ;
3184
3185	//m_MapName="testnew00a.bsp" ;
3186	//m_MapName="test04gNew.bsp" ;
3187
3188	//m_MapName="test10a.bsp" ;
3189	m_MapName="testmap06.bsp" ;
3190
3191
3192	//////////////////////////////////////////////////////////////////////////////////////////////////
3193	// Load the file, get the data
3194
3195
3196
3197	// open the stream to the bsp
3198	Ogre::DataStreamPtr stream = Ogre::ResourceGroupManager::getSingleton().openResource(m_MapName, ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, true);
3199
3200	// create memory to hold the bsp
3201	size_t Size = stream->size() ;
3202	m_pRawBspFile= new char[Size] ;
3203	if( m_pRawBspFile==NULL)
3204	{ m_pLog->logMessage("Error loading map: Initial load out of memory.") ; UnloadMap(false) ; return 0 ; }
3205	else
3206	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pRawBspFile]++ ; }
3207
3208	// stream bsp into memory
3209	stream->read((void*)m_pRawBspFile, Size) ;
3210
3211	// close the stream, don't need it anymore
3212	stream->close() ;
3213
3214	// indicate that the raw bsp is loaded
3215	m_bRawBspFileIsLoaded=true ;
3216
3217
3218
3219
3220
3221
3222	//////////////////////////////////////////////////////////////////////////////////////////////////
3223	// Setup Q3Map
3224
3225	m_Q3Map=new Q3Map();
3226	if(m_Q3Map==NULL)
3227	{ m_pLog->logMessage("Error loading map: New Map.") ; UnloadMap(false) ; return 0 ; }
3228	else
3229	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_Q3Map]++ ; }
3230
3231
3232
3233	m_pLog->logMessage("pre ParseMap") ;
3234
3235	// process the bsp, log errors and fail if needed.
3236	switch(m_Q3Map->ParseAndTriangulateMap( m_pRawBspFile, Size ) )
3237	{
3238	case ERROR_ParseMap: m_pLog->logMessage("Error loading map: Parse Map.") ; UnloadMap(false) ; return 0 ;
3239	case ERROR_ParseEntities: m_pLog->logMessage("Error loading map: Parse Entities.") ; UnloadMap(false) ; return 0 ;
3240	case ERROR_AllocateVertex: m_pLog->logMessage("Error loading map: Allocate Vertex.") ; UnloadMap(false) ; return 0 ;
3241	case ERROR_AllocateTriangle: m_pLog->logMessage("Error loading map: Allocate Triangle.") ; UnloadMap(false) ; return 0 ;
3242	case ERROR_InitializeFaces: m_pLog->logMessage("Error loading map: Initialize Faces") ; UnloadMap(false) ; return 0 ;
3243	case ERROR_ConvertFaces: m_pLog->logMessage("Error loading map: Convert Faces.") ; UnloadMap(false) ; return 0 ;
3244	case ERROR_ConvertPatches: m_pLog->logMessage("Error loading map: Convert Patches.") ; UnloadMap(false) ; return 0 ;
3245	case ERROR_ConvertTexLamp: m_pLog->logMessage("Error loading map: Convert TexLamps.") ; UnloadMap(false) ; return 0 ;
3246	case ERROR_ConvertLamps: m_pLog->logMessage("Error loading map: Convert Lamps.") ; UnloadMap(false) ; return 0 ;
3247	case ERROR_ConvertLampGlow: m_pLog->logMessage("Error loading map: Convert Lamp Glow.") ; UnloadMap(false) ; return 0 ;
3248	case ERROR_ConvertLightGlow: m_pLog->logMessage("Error loading map: Convert Light Glow.") ; UnloadMap(false) ; return 0 ;
3249	case ERROR_AssignTriangles: m_pLog->logMessage("Error loading map: Assign Triangles") ; UnloadMap(false) ; return 0 ;
3250	case ERROR_SortTriangles: m_pLog->logMessage("Error loading map: Sort Triangles") ; UnloadMap(false) ; return 0 ;
3251	case ERROR_SetupTransTextures: m_pLog->logMessage("Error loading map: Setup Trans Textures") ; UnloadMap(false) ; return 0 ;
3252	case ERROR_SortGroups: m_pLog->logMessage("Error loading map: Sort Groups") ; UnloadMap(false) ; return 0 ;
3253	}
3254
3255	m_pLog->logMessage("post ParseMap") ;
3256
3257	//////////////////////////////////////////////////////////////////////////////////////////////////
3258	// use the triangles to build our zone/texture manualObjects, which make up the map
3259	if(!ConstructMapFromTriangles()){ m_pLog->logMessage("Error loading map: Construct Map") ; UnloadMap(false) ; return 0 ; }
3260
3261	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3262	// delete all the stuff that was only needed for parsing the bsp and converting it into manaulObjects.
3263	m_Q3Map->FreeParseMem() ;
3264
3265
3266
3267
3268
3269
3270
3271	//////////////////////////////////////////////////////////////////////////////////////////////////
3272	// Create the scenenodes for the zones and attach the manualObjects
3273
3274	int nZone=0 ;
3275	char chSceneNodeName[1024] ;
3276	int nMO=0 ;
3277	int nZGStart=0 ;
3278	int nZGEnd=0 ;
3279
3280	char chMessage[1024] ;
3281	sprintf(chMessage, "Max Zones %i", m_Q3Map->m_nMaxZone) ; m_pLog->logMessage(chMessage) ;
3282	for(nZone=0 ; nZone<m_Q3Map->m_nMaxZone ; nZone++)
3283	{
3284	//sprintf(chMessage, "Zone %i Top", nZone) ; m_pLog->logMessage(chMessage) ;
3285
3286
3287	// create Opaque node if needed
3288	if(m_nOpaqueNodeUsed[nZone])
3289	{
3290	sprintf(chSceneNodeName, "Opaque%05i", nZone) ;
3291	m_pOpaqueNode[nZone]=m_pSceneMgr->getRootSceneNode()->createChildSceneNode(chSceneNodeName) ;
3292	}
3293
3294	// create Trans node if needed
3295	if(m_nTransNodeUsed[nZone])
3296	{
3297	sprintf(chSceneNodeName, "Trans%05i", nZone) ;
3298	m_pTransNode[nZone]=m_pSceneMgr->getRootSceneNode()->createChildSceneNode(chSceneNodeName) ;
3299	}
3300
3301	// create Lamp node if needed
3302	if(m_nLampNodeUsed[nZone])
3303	{
3304	sprintf(chSceneNodeName, "Lamp%05i", nZone) ;
3305	m_pLampNode[nZone]=m_pSceneMgr->getRootSceneNode()->createChildSceneNode(chSceneNodeName) ;
3306	}
3307
3308	// create Glow node if needed
3309	if(m_nGlowNodeUsed[nZone])
3310	{
3311	sprintf(chSceneNodeName, "Glow%05i", nZone) ;
3312	m_pGlowNode[nZone]=m_pSceneMgr->getRootSceneNode()->createChildSceneNode(chSceneNodeName) ;
3313	}
3314
3315	// get start and end of this zone's batches.
3316	// If there's none, the start and end will be the same. (don't have to worry about checking for m_pZoneMO[nZone]==NULL)
3317	nZGStart = m_nZoneMOStart[nZone] ;
3318	nZGEnd = m_nZoneMOStart[nZone+1] ;
3319
3320	//sprintf(chMessage, " Zone %i, ZGStart %i, ZGEnd %i", nZone, nZGStart, nZGEnd) ; m_pLog->logMessage(chMessage) ;
3321
3322	for(nMO=nZGStart ; nMO<nZGEnd ; nMO++)
3323	{
3324	//sprintf(chMessage, " Zone %i, nMO %i", nZone, nMO) ; m_pLog->logMessage(chMessage) ;
3325
3326	// attach the entity to the appropriate node
3327
3328	if(m_pZoneEntityMaterialType[nMO]==MAT_OPAQUE)
3329	m_pOpaqueNode[nZone]->attachObject( m_pZoneEntity[nMO] ) ;
3330	else
3331	if(m_pZoneEntityMaterialType[nMO]==MAT_GEL)
3332	m_pTransNode[nZone]->attachObject( m_pZoneEntity[nMO] ) ;
3333	else
3334	if(m_pZoneEntityMaterialType[nMO]==MAT_LAMP)
3335	m_pLampNode[nZone]->attachObject( m_pZoneEntity[nMO] ) ;
3336	else
3337	if(m_pZoneEntityMaterialType[nMO]==MAT_GLOW)
3338	m_pGlowNode[nZone]->attachObject( m_pZoneEntity[nMO] ) ;
3339	}
3340
3341	}
3342
3343
3344	// add the game entities
3345	if(!SetupGameEntities()) { m_pLog->logMessage("Error loading map: Setup Entities") ; UnloadMap(false) ; return 0 ; }
3346
3347
3348	// prior to the first frame, all zone scenenodes are detached.
3349	m_pSceneMgr->getRootSceneNode()->removeAllChildren() ;
3350
3351	//////////////////////////////////////////////////////////////////////////////////////////////////////
3352	// Setup the lights
3353
3354
3355
3356
3357	initLight() ;
3358
3359	//if(m_nDebugLightBox)
3360	// AddLightCullingBoxes() ;
3361
3362
3363	//if(m_nPortalDebug)
3364	// AddPortalBoxes() ;
3365
3366
3367	///////////////////////////////////////////////////////////////////////////////////////////////////
3368	// misc finalization of the map
3369
3370	m_nCameraZone=-1 ; // indicate that we need to look up the zone the player is in.
3371	m_nCameraZoneL=-1 ;
3372	m_nCameraZoneR=-1 ;
3373
3374	m_nMapLoaded=1 ; // map was loaded ok
3375
3376
3377
3378	// set the camera's start position here.
3379	// I tried setting it during startup, but for some strange reason it didn't work IF the camera was in a zone
3380	// but was ok if the camera started outside a zone. Bit of a mystery... but it makes more sense to set it here anyway.
3381	m_pCamera->setPosition(Vector3(0, 0, 0));
3382
3383	if(m_Q3Map->m_nLightMax>0) // make sure there's at least one light before we point to it!
3384	m_pCamera->lookAt(Ogre::Vector3(m_Q3Map->m_pLight[0].Position[0], m_Q3Map->m_pLight[0].Position[1], m_Q3Map->m_pLight[0].Position[2])) ;
3385
3386
3387
3388
3389	if(m_nGoggleMode==GOGGLE_MODE_TEST)
3390	CreateGogglesTestImage() ; // create the test goggles
3391	else
3392	if(m_nGoggleMode==GOGGLE_MODE_ON)
3393	CreateGoggles() ; // create the stereo goggles
3394
3395
3396	SetupParticles() ;
3397
3398
3399	m_pLog->logMessage("LoadMap bottom.") ;
3400
3401	// reset the game timer
3402	m_GameTime=0.0 ;
3403	m_nFrame=0 ;
3404
3405
3406
3407	//OFBug.MessageInt(m_nNewCount) ;
3408
3409	return 1 ;
3410	}
3411
3412	//''
3413	int OgreFramework::SetupParticles()
3414	{
3415	ParticleSystem::setDefaultNonVisibleUpdateTimeout(5); // set nonvisible timeout
3416
3417
3418
3419	// create some nice fireworks and place it at the origin
3420	//m_ps = m_pSceneMgr->createParticleSystem("Fireworks", "particle/fallspark00");
3421	m_ps = m_pSceneMgr->createParticleSystem("Fireworks", "particle/spark00");
3422	m_pParticleNode = m_pSceneMgr->getRootSceneNode()->createChildSceneNode("ParticleNode") ;
3423	m_pParticleNode->attachObject(m_ps) ;
3424
3425	//m_pParticleNode->setPosition(360.0f, 360.0f, -860.0f) ;
3426	m_pParticleNode->setPosition(586.0f, 228.0f, -520.0f) ;
3427
3428
3429	return 1 ;
3430	}
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444
3445
3446
3447
3448
3449
3450
3451	// take the sorted list of triangles and contruct our Zone manualObjects array, m_pZoneMO, etc
3452	// and setup all the materials.
3453	int OgreFramework::ConstructMapFromTriangles(void)
3454	{
3455
3456
3457	int nVert=0 ;
3458	int nMaxVertex=0 ;
3459
3460	float flPosX=0.0f ;
3461	float flPosY=0.0f ;
3462	float flPosZ=0.0f ;
3463	float flNormX=0.0f ;
3464	float flNormY=0.0f ;
3465	float flNormZ=0.0f ;
3466	float flTexU=0.0f ;
3467	float flTexV=0.0f ;
3468
3469	float flLampPosX=0.0f ;
3470	float flLampPosY=0.0f ;
3471	float flLampPosZ=0.0f ;
3472	float flLampBrightness=0.0f ;
3473	float flLampR=0.0f ;
3474	float flLampG=0.0f ;
3475	float flLampB=0.0f ;
3476
3477	int nVertA=0 ;
3478	int nVertB=0 ;
3479	int nVertC=0 ;
3480
3481	char chMessage[1024] ;
3482
3483	int nZone=0 ;
3484	char chManualName[1024] ; // name for manual objects we create
3485	char chMeshName[1024] ;
3486
3487	int nTriangle=0 ;
3488	// int nStart=0 ;
3489	int nEnd=0 ;
3490	int nMaterial=0 ;
3491	int nGroup=0 ;
3492	int nTri=0 ;
3493	int nPos=0 ;
3494
3495	ZeroMemory((void*)m_nOpaqueNodeUsed, sizeof(m_nOpaqueNodeUsed)) ; // set all as unused
3496	ZeroMemory((void*)m_nTransNodeUsed, sizeof(m_nTransNodeUsed)) ; // set all as unused
3497	ZeroMemory((void*)m_nLampNodeUsed, sizeof(m_nLampNodeUsed)) ; // set all as unused
3498	ZeroMemory((void*)m_nGlowNodeUsed, sizeof(m_nGlowNodeUsed)) ; // set all as unused
3499
3500	char chMaterial_Base[1024] ;
3501	MaterialPtr pMaterial_Base ; // used for checking if material scripts exist, and stored for the material switching that happens in deferred shading
3502
3503	char chMaterial_Fast[1024] ;
3504	MaterialPtr pMaterial_Fast ; // faster version of the base, mainly non-coloured shadowning.
3505
3506	char chMaterial_Black[1024] ;
3507	MaterialPtr pMaterial_Black ; // just plain black, or black with alpha testing.
3508
3509	char chMaterial_DfShColour[1024] ;
3510	MaterialPtr pMaterial_DfShColour ; // used for checking if material scripts exist, and stored for the material switching that happens in deferred shading
3511
3512
3513	char chMaterial_Shadow[1024] ;
3514	MaterialPtr pMaterial_Shadow ;
3515
3516	char chMaterial_ShadeFront[1024] ;
3517	MaterialPtr pMaterial_ShadeFront ;
3518
3519	char chMaterial_ShadeBack[1024] ;
3520	MaterialPtr pMaterial_ShadeBack ;
3521
3522	char chMaterial_DfShPosition[1024] ;
3523	MaterialPtr pMaterial_DfShPosition ;
3524
3525	char chMaterial_DfShDiffuse[1024] ;
3526	MaterialPtr pMaterial_DfShDiffuse ;
3527
3528	//char chMaterial_DSNormal[1024] ;
3529	//MaterialPtr pMaterial_DSNormal ;
3530
3531	char chMaterial_DfShFuncTNB[1024] ;
3532	MaterialPtr pMaterial_DfShFuncTNB ;
3533
3534	char chMaterial_DfShSpecular[1024] ;
3535	MaterialPtr pMaterial_DfShSpecular ;
3536
3537	char chMaterial_DfShEmissive[1024] ;
3538	MaterialPtr pMaterial_DfShEmissive ;
3539
3540	//char chMaterial_DfShData[1024] ;
3541	//MaterialPtr pMaterial_DfShData ;
3542
3543	char chMaterial_DfShMix[1024] ;
3544	MaterialPtr pMaterial_DfShMix ;
3545
3546	char chCompare[1024] ;
3547
3548	// for calculating bounds of mesh
3549	float flMinX=0.0f ;
3550	float flMinY=0.0f ;
3551	float flMinZ=0.0f ;
3552	float flMaxX=0.0f ;
3553	float flMaxY=0.0f ;
3554	float flMaxZ=0.0f ;
3555	// float flMidX=0.0f ;
3556	// float flMidY=0.0f ;
3557	// float flMidZ=0.0f ;
3558	float flDisX=0.0f ;
3559	float flDisY=0.0f ;
3560	float flDisZ=0.0f ;
3561	float flRadius=0.0f ;
3562	AxisAlignedBox AABB ;
3563	unsigned short src, dest; // for tangent vectors
3564
3565
3566	// Work out how many manual objects we are going to need. We need one for every group within every material within every zone.
3567	// Groups tend to all be 0 except for transparent triangles which have different groups within the same material/zone,
3568	// due to the need to sort and render transparent things in a specific depth order relative to the camera.
3569
3570
3571	int nMOCount=0 ;
3572	nMaterial=-1 ;
3573	nZone=-1 ;
3574	nGroup=-1 ;
3575
3576	// loop through all triangles to count how many manual objects we'll need.
3577	for(nTri=0 ; nTri<m_Q3Map->m_nTriangleMax ; nTri++)
3578	{
3579
3580	if(m_Q3Map->m_pTriangle[nTri].Zone!=nZone) // found a new zone
3581	{
3582	nZone=m_Q3Map->m_pTriangle[nTri].Zone ;
3583	nMaterial=m_Q3Map->m_pTriangle[nTri].Texture ;
3584	nGroup=m_Q3Map->m_pTriangle[nTri].Group ;
3585	nMOCount++ ;
3586	}
3587	else
3588	if(m_Q3Map->m_pTriangle[nTri].Texture!=nMaterial) // found a new material within the current zone
3589	{
3590	nMaterial=m_Q3Map->m_pTriangle[nTri].Texture ;
3591	nGroup=m_Q3Map->m_pTriangle[nTri].Group ;
3592	nMOCount++ ;
3593	}
3594	else
3595	if(m_Q3Map->m_pTriangle[nTri].Group!=nGroup) // found a new group within the current material within the current zone
3596	{
3597	nGroup=m_Q3Map->m_pTriangle[nTri].Group ;
3598	nMOCount++ ;
3599	}
3600
3601	}// end for tri
3602
3603
3604
3605	// create the manualobject array for our zones and materials
3606	m_pZoneMO = new Ogre::ManualObject*[nMOCount] ;
3607	if(m_pZoneMO==NULL)
3608	return 0 ; // fail, out of mem
3609	else
3610	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneMO]++ ; }
3611
3612	m_pZoneMesh = new Ogre::MeshPtr[nMOCount] ;
3613	if(m_pZoneMesh==NULL)
3614	return 0 ; // fail, out of mem
3615	else
3616	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneMesh]++ ; }
3617
3618	// our entities for the meshes
3619	m_pZoneEntity = new Ogre::Entity*[nMOCount] ;
3620	if(m_pZoneEntity==NULL)
3621	return 0 ; // fail, out of mem
3622	else
3623	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntity]++ ; }
3624
3625	// need to keep track of which entities are transparent
3626	m_pZoneEntityMaterialType = new int[nMOCount] ;
3627	if(m_pZoneEntityMaterialType==NULL)
3628	return 0 ; // fail, out of mem
3629	else
3630	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterialType]++ ; }
3631	ZeroMemory((void)m_pZoneEntityMaterialType, nMOCountsizeof(int)) ; // set all as non-transparent
3632
3633
3634	int nPTex=0 ;
3635	for(nPTex=0 ; nPTex<MAX_PROJECTORTEX ; nPTex++)
3636	{
3637	// our base materials for the meshes
3638	m_pZoneEntityMaterial_Base[nPTex] = new Ogre::MaterialPtr[nMOCount] ;
3639	if(m_pZoneEntityMaterial_Base[nPTex]==NULL)
3640	return 0 ; // fail, out of mem
3641	else
3642	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_Base]++ ; }
3643
3644	// our fast materials for the meshes
3645	m_pZoneEntityMaterial_Fast[nPTex] = new Ogre::MaterialPtr[nMOCount] ;
3646	if(m_pZoneEntityMaterial_Fast[nPTex]==NULL)
3647	return 0 ; // fail, out of mem
3648	else
3649	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_Fast]++ ; }
3650	}
3651
3652	// our black materials for the meshes
3653	m_pZoneEntityMaterial_Black = new Ogre::MaterialPtr[nMOCount] ;
3654	if(m_pZoneEntityMaterial_Black==NULL)
3655	return 0 ; // fail, out of mem
3656	else
3657	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_Black]++ ; }
3658
3659	// our base materials for the meshes
3660	m_pZoneEntityMaterial_DfShColour = new Ogre::MaterialPtr[nMOCount] ;
3661	if(m_pZoneEntityMaterial_DfShColour==NULL)
3662	return 0 ; // fail, out of mem
3663	else
3664	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_DfShColour]++ ; }
3665
3666	// materials for the meshes
3667	m_pZoneEntityMaterial_Shadow = new Ogre::MaterialPtr[nMOCount] ;
3668	if(m_pZoneEntityMaterial_Shadow==NULL)
3669	return 0 ; // fail, out of mem
3670	else
3671	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_Shadow]++ ; }
3672
3673	// materials for the meshes
3674	m_pZoneEntityMaterial_ShadeFront = new Ogre::MaterialPtr[nMOCount] ;
3675	if(m_pZoneEntityMaterial_ShadeFront==NULL)
3676	return 0 ; // fail, out of mem
3677	else
3678	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_ShadeFront]++ ; }
3679
3680	// materials for the meshes
3681	m_pZoneEntityMaterial_ShadeBack = new Ogre::MaterialPtr[nMOCount] ;
3682	if(m_pZoneEntityMaterial_ShadeBack==NULL)
3683	return 0 ; // fail, out of mem
3684	else
3685	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_ShadeBack]++ ; }
3686
3687	// materials for the meshes
3688	m_pZoneEntityMaterial_DfShPosition = new Ogre::MaterialPtr[nMOCount] ;
3689	if(m_pZoneEntityMaterial_DfShPosition==NULL)
3690	return 0 ; // fail, out of mem
3691	else
3692	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_DfShPosition]++ ; }
3693
3694	// materials for the meshes
3695	m_pZoneEntityMaterial_DfShDiffuse = new Ogre::MaterialPtr[nMOCount] ;
3696	if(m_pZoneEntityMaterial_DfShDiffuse==NULL)
3697	return 0 ; // fail, out of mem
3698	else
3699	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_DfShDiffuse]++ ; }
3700
3701	// materials for the meshes
3702	//m_pZoneEntityMaterial_DSNormal = new Ogre::MaterialPtr[nMOCount] ;
3703	//if(m_pZoneEntityMaterial_DSNormal==NULL) return 0 ; // fail, out of mem
3704
3705	// materials for the meshes
3706	m_pZoneEntityMaterial_DfShFuncTNB = new Ogre::MaterialPtr[nMOCount] ;
3707	if(m_pZoneEntityMaterial_DfShFuncTNB==NULL)
3708	return 0 ; // fail, out of mem
3709	else
3710	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_DfShFuncTNB]++ ; }
3711
3712	// materials for the meshes
3713	m_pZoneEntityMaterial_DfShSpecular = new Ogre::MaterialPtr[nMOCount] ;
3714	if(m_pZoneEntityMaterial_DfShSpecular==NULL)
3715	return 0 ; // fail, out of mem
3716	else
3717	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_DfShSpecular]++ ; }
3718
3719	// materials for the meshes
3720	m_pZoneEntityMaterial_DfShEmissive = new Ogre::MaterialPtr[nMOCount] ;
3721	if(m_pZoneEntityMaterial_DfShEmissive==NULL)
3722	return 0 ; // fail, out of mem
3723	else
3724	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_DfShEmissive]++ ; }
3725
3726
3727	// materials for the meshes
3728	//m_pZoneEntityMaterial_DfShData = new Ogre::MaterialPtr[nMOCount] ;
3729	//if(m_pZoneEntityMaterial_DfShData==NULL) return 0 ; // fail, out of mem
3730
3731	// materials for the meshes
3732	m_pZoneEntityMaterial_DfShMix = new Ogre::MaterialPtr[nMOCount] ;
3733	if(m_pZoneEntityMaterial_DfShMix==NULL)
3734	return 0 ; // fail, out of mem
3735	else
3736	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pZoneEntityMaterial_DfShMix]++ ; }
3737
3738
3739	// memory for keeping track of re-assigned verts, since we only add verts to a manualobject if they are needed, we don't add every vertex
3740	int* pVertIndex = new int [m_Q3Map->m_nVertexMax] ; // at most, there can be m_Q3Map->m_nVertexMax verts in a zone if the map is one big subzone.
3741	if(pVertIndex==NULL) //{ CHECKDELETE_ARRAY( m_pZoneMO ) ; return 0 ; } // fail, out of mem
3742	return 0 ;
3743	else
3744	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_pVertIndex]++ ; }
3745
3746
3747
3748
3749
3750	// go through all the zones and create their manualobjects in m_pZoneMO, one for each material
3751	int nMOIndex=0 ;
3752	for(nZone=0 ; nZone<m_Q3Map->m_nMaxZone ; nZone++)
3753	{
3754	m_nZoneTriangleCount[nZone]=0 ; // just for our stats
3755
3756
3757	m_nZoneMOStart[nZone]=nMOIndex ; // record where we start from.
3758
3759	// because the triangles have been sorted in order of zone, if there are any triangles in this zone
3760	// then nTriangle will already be on the first example. However it could be there is a zone that contains
3761	// no triangles. If we have such an empty zone, we don't create any manual object for it and set its pointer
3762	// to NULL.
3763
3764	if(m_Q3Map->m_pTriangle[nTriangle].Zone!=nZone)
3765	{
3766	m_pZoneMO[nMOIndex]=NULL ;
3767	continue ;
3768	//break ;
3769	}
3770
3771
3772
3773
3774	// scan through all triangles in this zone
3775	while((nTriangle<m_Q3Map->m_nTriangleMax) && (m_Q3Map->m_pTriangle[nTriangle].Zone==nZone))
3776	{
3777
3778
3779
3780	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3781	//
3782	// start adding a begin/end block of all triangles in a zone with the same material/group
3783	//
3784	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3785
3786
3787
3788
3789
3790	nMaterial=m_Q3Map->m_pTriangle[nTriangle].Texture ;
3791	nGroup=m_Q3Map->m_pTriangle[nTriangle].Group ;
3792
3793
3794
3795
3796	// create the zone's manualobject
3797	sprintf(chManualName, "ZoneMO_%04i_%04i_%05i", nZone, nMaterial, nTriangle) ;
3798	m_pZoneMO[nMOIndex]=m_pSceneMgr->createManualObject(chManualName) ;
3799
3800
3801
3802	// scan forward to find the end of this block of triangles with the same texture and group
3803	nEnd=nTriangle+1 ;
3804	while(
3805	(nEnd<m_Q3Map->m_nTriangleMax)
3806	&&(m_Q3Map->m_pTriangle[nEnd].Zone==nZone)
3807	&&(m_Q3Map->m_pTriangle[nEnd].Texture==nMaterial)
3808	&&(m_Q3Map->m_pTriangle[nEnd].Group==nGroup)
3809	)
3810	nEnd++ ;
3811
3812	// copy the material name.
3813	// q3 texture names are a max of 64 characters ( Q3NAMESIZE ) and may not be null terminated. They have no extension either.
3814	nPos=-1 ;
3815	while((++nPos<Q3NAMESIZE) && (m_Q3Map->m_pTexture[nMaterial].name[nPos]!=' ') && (m_Q3Map->m_pTexture[nMaterial].name[nPos]!='\0'))
3816	chMaterial_Base[nPos]=m_Q3Map->m_pTexture[nMaterial].name[nPos] ;
3817
3818	// make sure name is null terminated
3819	chMaterial_Base[nPos]='\0' ;
3820
3821
3822
3823	//..
3824
3825	//if(strcmp(chMaterial_Base, "textures/common/exptex")==0) strcpy(chMaterial_Base, "GEL_ShinyGlassPlateTL") ;
3826	//if(strcmp(chMaterial_Base, "textures/common/exptex")==0) strcpy(chMaterial_Base, "GEL_DSC_Prototype") ;
3827	//if(strcmp(chMaterial_Base, "textures/common/exptex")==0) strcpy(chMaterial_Base, "GEL_DSC_Prototype") ;
3828	if(strcmp(chMaterial_Base, "textures/common/exptex")==0) strcpy(chMaterial_Base, "GEL_DSC_glassred") ;
3829	if(strcmp(chMaterial_Base, "textures/common/exptex2")==0) strcpy(chMaterial_Base, "GEL_GreyGlass") ;
3830	if(strcmp(chMaterial_Base, "textures/common/alphaplate")==0) strcpy(chMaterial_Base, "ALPHAPF_DSCE_Prototype") ;
3831	//if(strcmp(chMaterial_Base, "textures/common/alphaplate")==0) strcpy(chMaterial_Base, "OPAQUE_DSC_SimplePlateB") ;
3832	//if(strcmp(chMaterial_Base, "textures/common/alphaplate")==0) strcpy(chMaterial_Base, "ALPHAPF_DS_alphaplategreen") ;
3833
3834
3835
3836	// if the material is a lamp material we need to specify either an OpenGl or Direct3D version
3837	strcpy(chCompare, chMaterial_Base) ;
3838	chCompare[12]='\0' ;
3839	if(strcmp("lights/lamp_", chCompare)==0) // material is LAMP
3840	{
3841	if(m_IsOpenGL)
3842	strcat(chMaterial_Base, "_ogl") ;
3843	else
3844	strcat(chMaterial_Base, "_d3d") ;
3845
3846	}
3847
3848	strcpy(chCompare, chMaterial_Base) ;
3849	chCompare[17]='\0' ;
3850	if(strcmp("lights/lamp2pass_", chCompare)==0) // material is LAMP, 2 pass version
3851	{
3852	if(m_IsOpenGL)
3853	strcat(chMaterial_Base, "_ogl") ;
3854	else
3855	strcat(chMaterial_Base, "_d3d") ;
3856	}
3857
3858
3859
3860	// check that this material script exists, if not set to the default
3861	pMaterial_Base=MaterialManager::getSingleton().getByName(chMaterial_Base) ;
3862	if(pMaterial_Base.isNull())
3863	{
3864	strcat(chMaterial_Base, " * MISSING *") ;
3865	// OFBug.LogAddCR(chMaterial_Base) ;
3866
3867	//sprintf(chMessage, "Missing material, using default: %s", chMaterial_Base) ;
3868	//m_pLog->logMessage(chMessage);
3869
3870	/*
3871	switch(rand()%6)
3872	{
3873	case 0: strcpy(chMaterial_Base, "OPAQUE_DSC_Plate2x2A") ; break ;
3874	case 1: strcpy(chMaterial_Base, "OPAQUE_DSC_HexColourA") ; break ;
3875	case 2: strcpy(chMaterial_Base, "OPAQUE_DSC_SimplePlateB") ; break ;
3876	case 3: strcpy(chMaterial_Base, "OPAQUE_DSC_FloorA") ; break ;
3877	case 4: strcpy(chMaterial_Base, "OPAQUE_DSCE_WallTrimUD_A") ; break ;
3878	case 5: strcpy(chMaterial_Base, "OPAQUE_DSCE_TechRadar") ; break ;
3879	}
3880	*/
3881
3882	//strcpy(chMaterial_Base, "OPAQUE_DSC_SimplePlateB") ;
3883
3884	//strcpy(chMaterial_Base, "OPAQUE_DSC_Plate2x2A") ;
3885	//strcpy(chMaterial_Base, "OPAQUE_DSC_HexColourA") ;
3886	//strcpy(chMaterial_Base, "OPAQUE_DSC_SimplePlateB") ;
3887	//strcpy(chMaterial_Base, "OPAQUE_DSC_FloorA") ;
3888	strcpy(chMaterial_Base, "textures/metaltech/OPAQUE_DSCE_TechRadar") ;
3889	//strcpy(chMaterial_Base, "OPAQUE_DSCE_WallTrimA") ;
3890	//strcpy(chMaterial_Base, "OPAQUE_DSCE_WallTrimB") ;
3891
3892	//strcpy(chMaterial_Base, "Standard_Normal") ;
3893	//strcpy(chMaterial_Base, "test") ;
3894	//strcpy(chMaterial_Base, "metalN") ;
3895	//strcpy(chMaterial_Base, "OPAQUE_DSC_Prototype") ;
3896
3897	//strcpy(chMaterial_Base, "textures/common/exptex") ;
3898	//strcpy(chMaterial_Base, "metalN_DSNormal") ;
3899	//strcpy(chMaterial_Base, "metalN_DfShFuncTNB") ;
3900	//strcpy(chMaterial_Base, "metalN_DfShDiffuse") ;
3901	//strcpy(chMaterial_Base, "metalN_DfShPosition") ;
3902	//strcpy(chMaterial_Base, "metalD") ;
3903	//strcpy(chMaterial_Base, "metalR") ;
3904	//strcpy(chMaterial_Base, "WonderShader_Lim3_Fast") ;
3905	//strcpy(chMaterial_Base, "reliefMaterial") ;
3906	//strcpy(chMaterial_Base, "tute02") ;reliefMaterial
3907	//strcpy(chMaterial_Base, "Examples/OffsetMapping/Specular") ;
3908	pMaterial_Base=MaterialManager::getSingleton().getByName(chMaterial_Base) ;
3909	}
3910	else
3911	// OFBug.LogAddCR(chMaterial_Base) ;
3912
3913
3914
3915	if(nMOIndex==20)
3916	{
3917	sprintf(m_chBug, "**** %s *****", chMaterial_Base) ;
3918	m_pLog->logMessage(m_chBug);
3919	}
3920
3921
3922
3923
3924	// setup whether this material and it's entities are transparent or whatever
3925
3926	if(strstr(chMaterial_Base, "OPAQUE")!=NULL) // material and its entity are OPAQUE
3927	{
3928	m_nOpaqueNodeUsed[nZone]=1 ;
3929	m_pZoneEntityMaterialType[nMOIndex]=MAT_OPAQUE ; // note that the derived entity will be opaque
3930	}
3931	else
3932	{
3933
3934	if(strstr(chMaterial_Base, "ALPHAPF")!=NULL) // material and its entity are ALPHAPF
3935	{
3936	m_nOpaqueNodeUsed[nZone]=1 ;
3937	m_pZoneEntityMaterialType[nMOIndex]=MAT_OPAQUE ; // note that the derived entity will be opaque
3938	}
3939	else
3940	{
3941
3942	if(strstr(chMaterial_Base, "GEL")!=NULL) // material and its entity are GEL
3943	{
3944	m_nTransNodeUsed[nZone]=1 ;
3945	m_pZoneEntityMaterialType[nMOIndex]=MAT_GEL ; // note that the derived entity will be transparent
3946	}
3947	else
3948	{
3949
3950	strcpy(chCompare, chMaterial_Base) ;
3951	chCompare[12]='\0' ;
3952	if(strcmp("lights/lamp_", chCompare)==0) // material and its entity are LAMP (spotlights don't ever make triangles, only lamps)
3953	{
3954	m_nLampNodeUsed[nZone]=1 ;
3955	m_pZoneEntityMaterialType[nMOIndex]=MAT_LAMP ; // note that the derived entity will be lamp
3956	}
3957	else
3958	{
3959	strcpy(chCompare, chMaterial_Base) ;
3960	chCompare[17]='\0' ;
3961	if(strcmp("lights/lamp2pass_", chCompare)==0) // material and its entity are LAMP (spotlights don't ever make triangles, only lamps)
3962	{
3963	m_nLampNodeUsed[nZone]=1 ;
3964	m_pZoneEntityMaterialType[nMOIndex]=MAT_LAMP ; // note that the derived entity will be lamp
3965	}
3966	else
3967	{
3968
3969	if(strstr(chMaterial_Base, "GLOW_")!=NULL) // material and its entity are GLOW
3970	{
3971	m_nGlowNodeUsed[nZone]=1 ;
3972	m_pZoneEntityMaterialType[nMOIndex]=MAT_GLOW ; // note that the derived entity will be glow
3973	}
3974	}
3975	}
3976	}
3977	}
3978	}
3979
3980
3981
3982
3983
3984
3985	///////////////////////////////////////////////////////////////////////////////////////////////////////
3986	//
3987	// Setup the different material names and pointers needed for various passes
3988	//
3989	// Lamps need only one material, pMaterial_Base, which is already assigned above, so it skips all this.
3990	//
3991	// Glow needs two materials, pMaterial_Base plus pMaterial_DfShColour for the coloured gel deferred pass.
3992	// However it's better to make a third, and duplicate the pMaterial_Base to pMaterial_Emissive, since
3993	// when glow gets rendered on the Emmisive pass it would be odd to switch to the base material instead
3994	// of the emmisive.
3995	//
3996	// Other objects need multiple materials for various different deferred shading and FX passes
3997
3998	if((m_pZoneEntityMaterialType[nMOIndex]!=MAT_LAMP) && (m_pZoneEntityMaterialType[nMOIndex]!=MAT_GLOW))
3999	{
4000
4001	// material for fast shading
4002	strcpy(chMaterial_Fast, chMaterial_Base) ;
4003	strcat(chMaterial_Fast, "_Fast") ;
4004
4005	pMaterial_Fast=MaterialManager::getSingleton().getByName(chMaterial_Fast) ;
4006	if(pMaterial_Fast.isNull())
4007	{
4008	sprintf(chMessage, "Missing material, using default: %s", chMaterial_Fast) ;
4009	m_pLog->logMessage(chMessage);
4010
4011	strcpy(chMaterial_Fast, "Fast") ;
4012	pMaterial_Fast=MaterialManager::getSingleton().getByName(chMaterial_Fast) ;
4013	}
4014
4015	// material for black shading
4016	strcpy(chMaterial_Black, chMaterial_Base) ;
4017	strcat(chMaterial_Black, "_Black") ;
4018	pMaterial_Black=MaterialManager::getSingleton().getByName(chMaterial_Black) ;
4019	if(pMaterial_Black.isNull())
4020	{
4021	// only issue a warning if this is an alpha testing material, others don't need specialized Black materials
4022	if(strstr(chMaterial_Base, "ALPHAPF")!=NULL)
4023	{
4024	sprintf(chMessage, "Missing material, using default: %s", chMaterial_Black) ;
4025	m_pLog->logMessage(chMessage);
4026	}
4027
4028	strcpy(chMaterial_Black, "Black") ;
4029	pMaterial_Black=MaterialManager::getSingleton().getByName(chMaterial_Black) ;
4030	}
4031
4032	// material for shadow casting
4033	strcpy(chMaterial_Shadow, chMaterial_Base) ;
4034	strcat(chMaterial_Shadow, "_Shadow") ;
4035	pMaterial_Shadow=MaterialManager::getSingleton().getByName(chMaterial_Shadow) ;
4036	if(pMaterial_Shadow.isNull())
4037	{
4038	strcpy(chMaterial_Shadow, "OPAQUE_Shadow") ;
4039	pMaterial_Shadow=MaterialManager::getSingleton().getByName(chMaterial_Shadow) ;
4040	}
4041
4042
4043
4044	// material for shadow casting
4045	strcpy(chMaterial_ShadeFront, chMaterial_Base) ;
4046	strcat(chMaterial_ShadeFront, "_ShadeFront") ;
4047	pMaterial_ShadeFront=MaterialManager::getSingleton().getByName(chMaterial_ShadeFront) ;
4048	if(pMaterial_ShadeFront.isNull())
4049	{
4050	// standard opaque ShadeFront.
4051	// Transparent surfaces MUST have their own _ShadeFront material or they will not colour light and can interfere with other trans surfaces.
4052	strcpy(chMaterial_ShadeFront, "OPAQUE_ShadeFront") ;
4053
4054	pMaterial_ShadeFront=MaterialManager::getSingleton().getByName(chMaterial_ShadeFront) ;
4055	}
4056
4057
4058	// material for shadow casting
4059	strcpy(chMaterial_ShadeBack, chMaterial_Base) ;
4060	strcat(chMaterial_ShadeBack, "_ShadeBack") ;
4061	pMaterial_ShadeBack=MaterialManager::getSingleton().getByName(chMaterial_ShadeBack) ;
4062	if(pMaterial_ShadeBack.isNull())
4063	{
4064	// standard opaque ShadeBack.
4065	// Transparent surfaces MUST have their own _ShadeBack material or they will not colour light and can interfere with other trans surfaces.
4066	strcpy(chMaterial_ShadeBack, "OPAQUE_ShadeBack") ;
4067
4068	pMaterial_ShadeBack=MaterialManager::getSingleton().getByName(chMaterial_ShadeBack) ;
4069	}
4070
4071	// material for deferred shading
4072	strcpy(chMaterial_DfShColour, chMaterial_Base) ;
4073	strcat(chMaterial_DfShColour, "_DfShColour") ;
4074	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
4075	if(pMaterial_DfShColour.isNull())
4076	{
4077	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShColour) ;
4078	m_pLog->logMessage(chMessage);
4079
4080	strcpy(chMaterial_DfShColour, "DfShColour") ;
4081	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
4082	}
4083
4084
4085	// material for deferred shading
4086	strcpy(chMaterial_DfShPosition, chMaterial_Base) ;
4087	strcat(chMaterial_DfShPosition, "_DfShPosition") ;
4088	pMaterial_DfShPosition=MaterialManager::getSingleton().getByName(chMaterial_DfShPosition) ;
4089	if(pMaterial_DfShPosition.isNull())
4090	{
4091	// only issue a warning if this is an alpha testing material, others don't need specialized DfShPosition materials
4092	if(strstr(chMaterial_Base, "ALPHAPF")!=NULL)
4093	{
4094	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShPosition) ;
4095	m_pLog->logMessage(chMessage);
4096	}
4097
4098	strcpy(chMaterial_DfShPosition, "DfShPosition") ;
4099	pMaterial_DfShPosition=MaterialManager::getSingleton().getByName(chMaterial_DfShPosition) ;
4100	}
4101
4102	// material for deferred shading
4103	strcpy(chMaterial_DfShDiffuse, chMaterial_Base) ;
4104	strcat(chMaterial_DfShDiffuse, "_DfShDiffuse") ;
4105	pMaterial_DfShDiffuse=MaterialManager::getSingleton().getByName(chMaterial_DfShDiffuse) ;
4106	if(pMaterial_DfShDiffuse.isNull())
4107	{
4108	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShDiffuse) ;
4109	m_pLog->logMessage(chMessage);
4110
4111	strcpy(chMaterial_DfShDiffuse, "DfShDiffuse") ;
4112	pMaterial_DfShDiffuse=MaterialManager::getSingleton().getByName(chMaterial_DfShDiffuse) ;
4113	}
4114
4115	/*
4116	// material for deferred shading // UNUSED
4117	strcpy(chMaterial_DSNormal, chMaterial_Base) ;
4118	strcat(chMaterial_DSNormal, "_DSNormal") ;
4119	pMaterial_DSNormal=MaterialManager::getSingleton().getByName(chMaterial_DSNormal) ;
4120	if(pMaterial_DSNormal.isNull())
4121	{
4122	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DSNormal) ;
4123	m_pLog->logMessage(chMessage);
4124
4125	strcpy(chMaterial_DSNormal, "DSNormal") ;
4126	pMaterial_DSNormal=MaterialManager::getSingleton().getByName(chMaterial_DSNormal) ;
4127	}
4128	*/
4129
4130	// material for deferred shading
4131	strcpy(chMaterial_DfShFuncTNB, chMaterial_Base) ;
4132	strcat(chMaterial_DfShFuncTNB, "_DfShFuncTNB") ;
4133	pMaterial_DfShFuncTNB=MaterialManager::getSingleton().getByName(chMaterial_DfShFuncTNB) ;
4134	if(pMaterial_DfShFuncTNB.isNull())
4135	{
4136	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShFuncTNB) ;
4137	m_pLog->logMessage(chMessage);
4138
4139	strcpy(chMaterial_DfShFuncTNB, "DfShFuncTNB") ;
4140	pMaterial_DfShFuncTNB=MaterialManager::getSingleton().getByName(chMaterial_DfShFuncTNB) ;
4141	}
4142
4143	// material for deferred shading
4144	strcpy(chMaterial_DfShSpecular, chMaterial_Base) ;
4145	strcat(chMaterial_DfShSpecular, "_DfShSpecular") ;
4146	pMaterial_DfShSpecular=MaterialManager::getSingleton().getByName(chMaterial_DfShSpecular) ;
4147	if(pMaterial_DfShSpecular.isNull())
4148	{
4149	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShSpecular) ;
4150	m_pLog->logMessage(chMessage);
4151
4152	strcpy(chMaterial_DfShSpecular, "DfShSpecular") ;
4153	pMaterial_DfShSpecular=MaterialManager::getSingleton().getByName(chMaterial_DfShSpecular) ;
4154	}
4155
4156	// material for deferred shading
4157	strcpy(chMaterial_DfShEmissive, chMaterial_Base) ;
4158	strcat(chMaterial_DfShEmissive, "_DfShEmissive") ;
4159	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
4160	if(pMaterial_DfShEmissive.isNull())
4161	{
4162	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShEmissive) ;
4163	m_pLog->logMessage(chMessage);
4164
4165	strcpy(chMaterial_DfShEmissive, "DfShEmissive") ;
4166	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
4167	}
4168
4169
4170	/*
4171	// material for deferred shading
4172	strcpy(chMaterial_DfShData, chMaterial_Base) ;
4173	strcat(chMaterial_DfShData, "_DfShData") ;
4174	pMaterial_DfShData=MaterialManager::getSingleton().getByName(chMaterial_DfShData) ;
4175	if(pMaterial_DfShData.isNull())
4176	{
4177	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShData) ;
4178	m_pLog->logMessage(chMessage);
4179
4180	strcpy(chMaterial_DfShData, "DfShData") ;
4181	pMaterial_DfShData=MaterialManager::getSingleton().getByName(chMaterial_DfShData) ;
4182	}
4183	*/
4184
4185	// material for deferred shading
4186	strcpy(chMaterial_DfShMix, chMaterial_Base) ;
4187	strcat(chMaterial_DfShMix, "_DfShMix") ;
4188	pMaterial_DfShMix=MaterialManager::getSingleton().getByName(chMaterial_DfShMix) ;
4189	if(pMaterial_DfShMix.isNull())
4190	{
4191	// Pretty much all materials just use the default mix material,
4192	// so don't issue warnings if there isn't a specialized version
4193	//sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShMix) ;
4194	//m_pLog->logMessage(chMessage);
4195
4196	strcpy(chMaterial_DfShMix, "DfShMix") ;
4197	pMaterial_DfShMix=MaterialManager::getSingleton().getByName(chMaterial_DfShMix) ;
4198	}
4199
4200
4201
4202
4203
4204	}// end if not MAT_LAMP or MAT_GLOW
4205	else
4206	if(m_pZoneEntityMaterialType[nMOIndex]==MAT_GLOW) // the two materials that glow needs
4207	{
4208
4209	// when I get around to allowing user defined GLOW materials as well as the automatic ones,
4210	// this'll be the place to add it.
4211	// For now, just the automatically generated lamp/light stuff has a glow.
4212
4213	// if the base material was "GLOW_lamp"
4214	strcpy(chCompare, chMaterial_Base) ;
4215	chCompare[strlen("GLOW_lamp")]='\0' ;
4216	if(strcmp("GLOW_lamp", chCompare)==0)
4217	{
4218	strcpy(chMaterial_DfShColour, "GLOW_lampcol") ;
4219	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
4220
4221	strcpy(chMaterial_DfShEmissive, "GLOW_lamp") ;
4222	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
4223	}
4224	else
4225	{
4226
4227	// if the base material was "GLOW_light"
4228	strcpy(chCompare, chMaterial_Base) ;
4229	chCompare[strlen("GLOW_light")]='\0' ;
4230	if(strcmp("GLOW_light", chCompare)==0)
4231	{
4232	strcpy(chMaterial_DfShColour, "GLOW_lightcol") ;
4233	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
4234
4235	strcpy(chMaterial_DfShEmissive, "GLOW_light") ;
4236	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
4237	}
4238
4239	}
4240	}
4241
4242
4243
4244
4245
4246
4247	// work out which vertices we'll need, we don't add every vertex, just used ones.
4248	nMaxVertex=0 ;
4249	for(nVert=0 ; nVert<m_Q3Map->m_nVertexMax ; nVert++)
4250	pVertIndex[nVert]=-1 ; // initialize all verts as unused.
4251
4252
4253	// start defining the manualObject
4254	m_pZoneMO[nMOIndex]->begin(chMaterial_Base, RenderOperation::OT_TRIANGLE_LIST) ;
4255
4256
4257	// reset the min max stuff
4258	flMinX=flMinY=flMinZ=MINMAXLIMIT ;
4259	flMaxX=flMaxY=flMaxZ=-MINMAXLIMIT ;
4260
4261
4262	// add the verts. We avoid repeating the same vert multiple times where it is used by many triangles
4263	for(nTri=nTriangle ; nTri<nEnd ; nTri++)
4264	for(nVert=0 ; nVert<3 ; nVert++)
4265	{
4266	if(pVertIndex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ]==-1) // this vert hasn't been added yet
4267	{
4268	pVertIndex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ]=nMaxVertex++ ; // so we can correctly look it up when we add the triangles
4269
4270	flPosX=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].position[0] ;
4271	flPosY=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].position[1] ;
4272	flPosZ=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].position[2] ;
4273	flNormX=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].normal[0] ;
4274	flNormY=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].normal[1] ;
4275	flNormZ=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].normal[2] ;
4276
4277
4278
4279	// lamps have some different vertex data, also glow
4280	// lamp needs colour and also info about the origin, which is stored in the UVs.
4281	// glow only needs the colour, but it doesn't hurt to store the orgin too, no harm and simpler code.
4282	if((m_pZoneEntityMaterialType[nMOIndex]==MAT_LAMP) \|\| (m_pZoneEntityMaterialType[nMOIndex]==MAT_GLOW))
4283	{
4284	flLampPosX = m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].texcoord[0][0] ;
4285	flLampPosY = m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].texcoord[0][1] ;
4286	flLampPosZ = m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].texcoord[1][0] ;
4287	flLampBrightness= m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].texcoord[1][1] ;
4288
4289	flLampR=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].color[0]/255.0f ;
4290	flLampG=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].color[1]/255.0f ;
4291	flLampB=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].color[2]/255.0f ;
4292
4293	// set the vertex data
4294	m_pZoneMO[nMOIndex]->position(flPosX, flPosY, flPosZ) ;
4295	m_pZoneMO[nMOIndex]->normal(flNormX, flNormY, flNormZ) ;
4296	m_pZoneMO[nMOIndex]->textureCoord(flLampPosX, flLampPosY, flLampPosZ, flLampBrightness) ;
4297	m_pZoneMO[nMOIndex]->colour(flLampR, flLampG, flLampB) ;
4298
4299	}
4300	else // non-lamps
4301	{
4302	flTexU=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].texcoord[0][0] ;
4303	flTexV=m_Q3Map->m_pVertex[ m_Q3Map->m_pTriangle[nTri].VIndex[nVert] ].texcoord[0][1] ;
4304
4305	// set the vertex data
4306	m_pZoneMO[nMOIndex]->position(flPosX, flPosY, flPosZ) ;
4307	m_pZoneMO[nMOIndex]->normal(flNormX, flNormY, flNormZ) ;
4308	m_pZoneMO[nMOIndex]->textureCoord(flTexU, flTexV) ;
4309	}
4310
4311	// update bounds
4312	if(flPosX<flMinX) flMinX=flPosX ;
4313	if(flPosY<flMinY) flMinY=flPosY ;
4314	if(flPosZ<flMinZ) flMinZ=flPosZ ;
4315	if(flPosX>flMaxX) flMaxX=flPosX ;
4316	if(flPosY>flMaxY) flMaxY=flPosY ;
4317	if(flPosZ>flMaxZ) flMaxZ=flPosZ ;
4318
4319	}// end if adding vert
4320	}
4321
4322	// add the triangles
4323	for(nTri=nTriangle ; nTri<nEnd ; nTri++)
4324	{
4325	nVertA=pVertIndex[ m_Q3Map->m_pTriangle[nTri].VIndex[0] ] ;
4326	nVertB=pVertIndex[ m_Q3Map->m_pTriangle[nTri].VIndex[1] ] ;
4327	nVertC=pVertIndex[ m_Q3Map->m_pTriangle[nTri].VIndex[2] ] ;
4328	m_pZoneMO[nMOIndex]->triangle(nVertA, nVertC, nVertB) ;
4329	m_nZoneTriangleCount[nZone]++ ;
4330	//m_pZoneMO[nMOIndex]->triangle(nVertA, nVertB, nVertC) ;
4331	}
4332
4333
4334	// all done for this block of material
4335	m_pZoneMO[nMOIndex]->end() ;
4336	m_pZoneMO[nMOIndex]->setCastShadows(true) ;
4337	m_pZoneMO[nMOIndex]->setDynamic(false) ;
4338
4339	// convert the manualobject to a mesh
4340	sprintf(chMeshName, "ZoneMesh_%04i_%04i_%05i", nZone, nMaterial, nTriangle) ;
4341	m_pZoneMesh[nMOIndex]= m_pZoneMO[nMOIndex]->convertToMesh(chMeshName);
4342
4343	// don't need the manual object anymore
4344	m_pSceneMgr->destroyManualObject(m_pZoneMO[nMOIndex]) ;
4345
4346
4347	// temp cludge to add thickness
4348	flMinX-=1.0f ;
4349	flMinY-=1.0f ;
4350	flMinZ-=1.0f ;
4351	flMaxX+=1.0f ;
4352	flMaxY+=1.0f ;
4353	flMaxZ+=1.0f ;
4354
4355	// set axis aligned bounding box of this mesh
4356	AABB.setMinimumX(flMinX) ;
4357	AABB.setMinimumY(flMinY) ;
4358	AABB.setMinimumZ(flMinZ) ;
4359	AABB.setMaximumX(flMaxX) ;
4360	AABB.setMaximumY(flMaxY) ;
4361	AABB.setMaximumZ(flMaxZ) ;
4362	m_pZoneMesh[nMOIndex]->_setBounds(AABB, false) ;
4363
4364	// set bounding sphere of this mesh
4365	flDisX=flMaxX-flMinX ;
4366	flDisY=flMaxY-flMinY ;
4367	flDisZ=flMaxZ-flMinZ ;
4368	flRadius=sqrt( flDisXflDisX + flDisYflDisY + flDisZ*flDisZ )/2.0 ;
4369	m_pZoneMesh[nMOIndex]->_setBoundingSphereRadius(flRadius) ;
4370
4371
4372	//if(strcmp(chMaterial_Base, "textures/metaltech/GEL_DSC_glassred")==0)
4373	// OFBug.MessageFloat(flRadius, flMinX, flMinY, flMinZ, flMaxX, flMaxY, flMaxZ) ;
4374
4375	//if(strcmp(chMaterial_Base, "textures/metaltech/GEL_DSC_glassgreen")==0)
4376	// OFBug.MessageFloat(flRadius, flMinX, flMinY, flMinZ, flMaxX, flMaxY, flMaxZ) ;
4377
4378	// calculate tangents for the mesh
4379	if((m_pZoneEntityMaterialType[nMOIndex]!=MAT_LAMP) && (m_pZoneEntityMaterialType[nMOIndex]!=MAT_GLOW))// lamps and glow don't need tangent vectors
4380	{
4381	m_pZoneMesh[nMOIndex]->suggestTangentVectorBuildParams(VES_TANGENT, src, dest) ;
4382	m_pZoneMesh[nMOIndex]->buildTangentVectors(VES_TANGENT, src, dest);
4383	}
4384
4385	m_pZoneMesh[nMOIndex]->load() ;
4386
4387	m_pZoneMesh[nMOIndex]->getSubMesh(0)->generateExtremes(8) ;
4388
4389	// create an entity for this mesh. We need this so we can change the material during deferred shading
4390	m_pZoneEntity[nMOIndex]=m_pSceneMgr->createEntity(m_pZoneMesh[nMOIndex]->getName(), m_pZoneMesh[nMOIndex]->getName()) ;
4391
4392	// if the entity is a lamp or glow, set its material because they never get changed
4393	if((m_pZoneEntityMaterialType[nMOIndex]==MAT_LAMP) \|\| (m_pZoneEntityMaterialType[nMOIndex]==MAT_GLOW))
4394	m_pZoneEntity[nMOIndex]->setMaterial( pMaterial_Base) ;
4395
4396
4397	//AABB=m_pZoneEntity[nMOIndex]->getBoundingBox() ;
4398	//Ogre::Vector3 mn, mx ;
4399	//mn=AABB.getMinimum() ;
4400	//mx=AABB.getMaximum() ;
4401	//if(strcmp(chMaterial_Base, "textures/metaltech/GEL_DSC_glassred")==0)
4402	// OFBug.MessageFloat(mn.x, mn.y, mn.z, mx.x, mx.y, mx.z) ;
4403
4404
4405
4406
4407
4408
4409	// store the pointers to the materials of this entity
4410	//m_pZoneEntityMaterial_Base[nMOIndex]=pMaterial_Base ;
4411	//m_pZoneEntityMaterial_Fast[nMOIndex]=pMaterial_Fast ;
4412	m_pZoneEntityMaterial_Black[nMOIndex]=pMaterial_Black ;
4413	m_pZoneEntityMaterial_DfShColour[nMOIndex]=pMaterial_DfShColour ;
4414	m_pZoneEntityMaterial_Shadow[nMOIndex]=pMaterial_Shadow ;
4415	m_pZoneEntityMaterial_ShadeFront[nMOIndex]=pMaterial_ShadeFront ;
4416	m_pZoneEntityMaterial_ShadeBack[nMOIndex]=pMaterial_ShadeBack ;
4417	m_pZoneEntityMaterial_DfShPosition[nMOIndex]=pMaterial_DfShPosition ;
4418	m_pZoneEntityMaterial_DfShDiffuse[nMOIndex]=pMaterial_DfShDiffuse ;
4419	//m_pZoneEntityMaterial_DSNormal[nMOIndex]=pMaterial_DSNormal ;
4420	m_pZoneEntityMaterial_DfShFuncTNB[nMOIndex]=pMaterial_DfShFuncTNB ;
4421	m_pZoneEntityMaterial_DfShSpecular[nMOIndex]=pMaterial_DfShSpecular ;
4422	m_pZoneEntityMaterial_DfShEmissive[nMOIndex]=pMaterial_DfShEmissive ;
4423	//m_pZoneEntityMaterial_DfShData[nMOIndex]=pMaterial_DfShData ;
4424	m_pZoneEntityMaterial_DfShMix[nMOIndex]=pMaterial_DfShMix ;
4425
4426
4427	//////////////////////////////////////////////////////////////////////////////////////////
4428
4429	char chNewName[1024] ;
4430	for(nPTex=0 ; nPTex<MAX_PROJECTORTEX ; nPTex++)
4431	{
4432	Ogre::AliasTextureNamePairList AliasList ;
4433
4434	// check the necessary texture exists
4435	//if(TextureManager::getSingleton().getByName(m_Q3Map->m_chSpotlightTexture[nPTex]).isNull())
4436	// OFBug.MessageInt(666) ;
4437
4438
4439	AliasList.insert(AliasTextureNamePairList::value_type("projector_tex", m_Q3Map->m_chSpotlightTexture[nPTex]));
4440
4441
4442
4443	sprintf(chNewName, "%s_%i", chMaterial_Base, 0) ;
4444	m_pZoneEntityMaterial_Base[nPTex][nMOIndex]=pMaterial_Base->clone(chNewName) ;
4445	// change the texture unit
4446	m_pZoneEntityMaterial_Base[nPTex][nMOIndex]->applyTextureAliases(AliasList) ;
4447
4448	sprintf(chNewName, "%s_%i", chMaterial_Fast, 0) ;
4449	m_pZoneEntityMaterial_Fast[nPTex][nMOIndex]=pMaterial_Fast->clone(chNewName) ;
4450	// change the texture unit
4451	m_pZoneEntityMaterial_Fast[nPTex][nMOIndex]->applyTextureAliases(AliasList) ;
4452
4453	}
4454
4455
4456
4457	//////////////////////////////////////////////////////////////////////////////////////////
4458
4459
4460	// move to the end of this block of materials
4461	nTriangle=nEnd ;
4462	nMOIndex++ ;
4463
4464
4465	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4466	//
4467	// end adding a begin/end block of all triangles in a zone with the same material
4468	//
4469	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4470
4471
4472
4473
4474	}// end scanning triangles in a zone
4475
4476
4477
4478	}// end looping through all zones
4479
4480	m_nZoneMOStart[m_Q3Map->m_nMaxZone]=nMOIndex ; // indicates the end pos of all the manual objects
4481
4482	CHECKDELETE_ARRAY( pVertIndex, NEW_CHECK_pVertIndex ); // free the vert index memory we used
4483
4484	CHECKDELETE_ARRAY( m_pZoneMO, NEW_CHECK_m_pZoneMO ) ; // free the manual object memory we used
4485	// quick check
4486	if(nMOCount!=nMOIndex)
4487	{
4488	sprintf(chMessage, "ERROR ConstructMap: MOIndex %i does not match MOCount %i", nMOIndex, nMOCount) ;
4489	m_pLog->logMessage(chMessage);
4490	//CHECKDELETE_ARRAY( m_pZoneMO ) ;
4491	CHECKDELETE_ARRAY( m_pZoneMesh, NEW_CHECK_m_pZoneMesh ) ;
4492	CHECKDELETE_ARRAY( m_pZoneEntity, NEW_CHECK_m_pZoneEntity ) ;
4493	CHECKDELETE_ARRAY( m_pZoneEntityMaterialType, NEW_CHECK_m_pZoneEntityMaterialType ) ;
4494
4495	for(nPTex=0 ; nPTex<MAX_PROJECTORTEX ; nPTex++)
4496	{
4497	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Base[nPTex], NEW_CHECK_m_pZoneEntityMaterial_Base ) ;
4498	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Fast[nPTex], NEW_CHECK_m_pZoneEntityMaterial_Fast ) ;
4499	}
4500
4501	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Black, NEW_CHECK_m_pZoneEntityMaterial_Black ) ;
4502	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShColour, NEW_CHECK_m_pZoneEntityMaterial_DfShColour ) ;
4503	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_Shadow, NEW_CHECK_m_pZoneEntityMaterial_Shadow ) ;
4504	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_ShadeFront, NEW_CHECK_m_pZoneEntityMaterial_ShadeFront ) ;
4505	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_ShadeBack, NEW_CHECK_m_pZoneEntityMaterial_ShadeBack ) ;
4506	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShPosition, NEW_CHECK_m_pZoneEntityMaterial_DfShPosition ) ;
4507	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShDiffuse, NEW_CHECK_m_pZoneEntityMaterial_DfShDiffuse ) ;
4508	//CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DSNormal ) ;
4509	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShFuncTNB, NEW_CHECK_m_pZoneEntityMaterial_DfShFuncTNB ) ;
4510	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShSpecular, NEW_CHECK_m_pZoneEntityMaterial_DfShSpecular ) ;
4511	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShEmissive, NEW_CHECK_m_pZoneEntityMaterial_DfShEmissive ) ;
4512	//CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShData ) ;
4513	CHECKDELETE_ARRAY( m_pZoneEntityMaterial_DfShMix, NEW_CHECK_m_pZoneEntityMaterial_DfShMix ) ;
4514
4515
4516	return 0 ;
4517	}
4518
4519
4520	return 1 ;
4521
4522	}
4523
4524	////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4525	//
4526	// setup the game entities
4527	//
4528
4529	int OgreFramework::SetupGameEntities(void)
4530	{
4531	int nEntity=0 ;
4532	char chMeshName[1024] ;
4533
4534
4535	// work out the maximum number of entities we need
4536	m_nMaxEntity=10 ;
4537	int nHalfMax=m_nMaxEntity/2 ;
4538
4539
4540
4541
4542	// create the dynamic memory for the entities
4543	m_pEntityInfo=new ENTITYINFO[m_nMaxEntity] ;
4544	if(m_pEntityInfo==NULL)
4545	return 0 ;
4546	else
4547	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pEntityInfo]++ ; }
4548
4549	m_pVisibleEntity=new int[m_nMaxEntity] ;
4550	if(m_pVisibleEntity==NULL)
4551	return 0 ;
4552	else
4553	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pVisibleEntity]++ ; }
4554
4555	m_pFrustumEntity=new int[m_nMaxEntity] ;
4556	if(m_pFrustumEntity==NULL)
4557	return 0 ;
4558	else
4559	{m_nNewCount++ ; m_nNewCheck[NEW_CHECK_m_pFrustumEntity]++ ; }
4560
4561
4562
4563	// setup materials and default data for the entities
4564	for(nEntity=0 ; nEntity<m_nMaxEntity ; nEntity++)
4565	{
4566	//switch(nEntity%3)
4567	//{
4568	// case 0: strcpy(chMeshName, "robot.mesh") ; break ;
4569	// case 1: strcpy(chMeshName, "ninja.mesh") ; break ;
4570	// case 2: strcpy(chMeshName, "athene.mesh") ; break ;
4571	//}
4572
4573	strcpy(chMeshName, "robot.mesh") ;
4574
4575	SetupEntity(nEntity, chMeshName) ;
4576	}
4577
4578
4579
4580
4581	// setup start data for each entity
4582	for(nEntity=0 ; nEntity<nHalfMax ; nEntity++)
4583	{
4584	m_pEntityInfo[nEntity].Postition=Ogre::Vector3(750.0f, 128.0f, -1950.0f-nEntity*40.0f) ;
4585	//m_pEntityInfo[nEntity].pMasterNode->setPosition(750.0f, 128.0f, -1950.0f-nEntity*40.0f) ;
4586	}
4587
4588	for(nEntity=nHalfMax ; nEntity<m_nMaxEntity ; nEntity++)
4589	{
4590	m_pEntityInfo[nEntity].Postition=Ogre::Vector3(590.0f, 128.0f, -320.0f-nEntity*40.0f) ;
4591	//m_pEntityInfo[nEntity].pMasterNode->setPosition(590.0f, 128.0f, -320.0f-nEntity*40.0f) ;
4592	}
4593
4594
4595
4596	for(nEntity=0 ; nEntity<m_nMaxEntity ; nEntity++)
4597	{
4598	m_pEntityInfo[nEntity].Active=1 ;
4599	m_pVisibleEntity[nEntity]=nEntity ;
4600	m_pFrustumEntity[nEntity]=nEntity ;
4601	}
4602
4603
4604	m_nMaxVisibleEntity=m_nMaxEntity ;
4605	m_nMaxFrustumEntity=m_nMaxEntity ;
4606
4607	return 1 ;
4608
4609	}
4610
4611
4612	int OgreFramework::SetupEntity(int nEntity, char *chMeshName)
4613	{
4614
4615	char chEntityName[1024] ;
4616	//char chMeshName[1024] ;
4617
4618
4619	int nSubMesh=0 ;
4620	int nMaxSubMesh=0 ;
4621
4622
4623
4624	Ogre::String MaterialName ;
4625
4626
4627	char chMaterial_Base[1024] ;
4628	MaterialPtr pMaterial_Base ; // used for checking if material scripts exist, and stored for the material switching that happens in deferred shading
4629
4630	char chMaterial_Fast[1024] ;
4631	MaterialPtr pMaterial_Fast ; // faster version of the base, mainly non-coloured shadowning.
4632
4633	char chMaterial_Black[1024] ;
4634	MaterialPtr pMaterial_Black ; // just plain black, or black with alpha testing.
4635
4636	char chMaterial_DfShColour[1024] ;
4637	MaterialPtr pMaterial_DfShColour ; // used for checking if material scripts exist, and stored for the material switching that happens in deferred shading
4638
4639
4640	char chMaterial_Shadow[1024] ;
4641	MaterialPtr pMaterial_Shadow ;
4642
4643	char chMaterial_ShadeFront[1024] ;
4644	MaterialPtr pMaterial_ShadeFront ;
4645
4646	char chMaterial_ShadeBack[1024] ;
4647	MaterialPtr pMaterial_ShadeBack ;
4648
4649	char chMaterial_DfShPosition[1024] ;
4650	MaterialPtr pMaterial_DfShPosition ;
4651
4652	char chMaterial_DfShDiffuse[1024] ;
4653	MaterialPtr pMaterial_DfShDiffuse ;
4654
4655	//char chMaterial_DSNormal[1024] ;
4656	//MaterialPtr pMaterial_DSNormal ;
4657
4658	char chMaterial_DfShFuncTNB[1024] ;
4659	MaterialPtr pMaterial_DfShFuncTNB ;
4660
4661	char chMaterial_DfShSpecular[1024] ;
4662	MaterialPtr pMaterial_DfShSpecular ;
4663
4664	char chMaterial_DfShEmissive[1024] ;
4665	MaterialPtr pMaterial_DfShEmissive ;
4666
4667	//char chMaterial_DfShData[1024] ;
4668	//MaterialPtr pMaterial_DfShData ;
4669
4670	char chMaterial_DfShMix[1024] ;
4671	MaterialPtr pMaterial_DfShMix ;
4672
4673	char chCompare[1024] ;
4674
4675	unsigned short src, dest; // for tangent vectors
4676
4677	char chMasterNodeName[1024] ;
4678	char chSubNodeName[1024] ;
4679
4680	char chMessage[1024] ;
4681	int nPTex=0 ;
4682
4683
4684	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
4685
4686	sprintf(chEntityName, "Entity_%05i", nEntity) ;
4687	//strcpy(chMeshName, "robot.mesh") ;
4688
4689
4690	// load the mesh
4691
4692	m_pEntityInfo[nEntity].pEnt=m_pSceneMgr->createEntity( chEntityName, chMeshName );
4693
4694	m_pEntityInfo[nEntity].TriangleCount=0 ;
4695
4696
4697	// create the master scenenode
4698	sprintf(chMasterNodeName, "Entity_%05i", nEntity) ;
4699	m_pEntityInfo[nEntity].pMasterNode=m_pSceneMgr->getRootSceneNode()->createChildSceneNode(chMasterNodeName) ;
4700	m_pEntityInfo[nEntity].pMasterNode->attachObject(m_pEntityInfo[nEntity].pEnt) ;
4701
4702	nMaxSubMesh=m_pEntityInfo[nEntity].pEnt->getMesh()->getNumSubMeshes() ;
4703	if(nMaxSubMesh>MAX_SUBMESH)
4704	{
4705	sprintf(m_chBug, "MESH ERROR: Mesh %s has %i submeshes, max is %i", chMeshName, m_pEntityInfo[nEntity].MaxSubMesh, MAX_SUBMESH) ;
4706	m_pLog->logMessage(m_chBug);
4707	nMaxSubMesh=MAX_SUBMESH ;
4708	}
4709	m_pEntityInfo[nEntity].MaxSubMesh=nMaxSubMesh ;
4710
4711	sprintf(m_chBug, "Entity %i, Mesh %s, MaxSubMesh %i", nEntity, chMeshName, m_pEntityInfo[nEntity].MaxSubMesh) ;
4712	m_pLog->logMessage(m_chBug);
4713
4714	// assign all the materials needed for all the submeshes
4715	for(nSubMesh=0 ; nSubMesh<nMaxSubMesh ; nSubMesh++)
4716	{
4717	// we count the triangles just for stats
4718	m_pEntityInfo[nEntity].TriangleCount += m_pEntityInfo[nEntity].pEnt->getMesh()->getSubMesh(nSubMesh)->indexData->indexCount/3 ;
4719
4720
4721	MaterialName=m_pEntityInfo[nEntity].pEnt->getMesh()->getSubMesh(nSubMesh)->getMaterialName() ;
4722
4723
4724
4725
4726	if(MaterialName.size()<512) // make sure name isn't too long before we copy it.
4727	strcpy(chMaterial_Base, MaterialName.c_str()) ;
4728	else
4729	{
4730	sprintf(m_chBug, "MESH ERROR: Mesh %s submesh %i material name is too long.", chMeshName, nSubMesh) ;
4731	m_pLog->logMessage(m_chBug);
4732	m_pLog->logMessage(MaterialName) ;
4733	chMaterial_Base[0]='\0' ; // no material
4734	}
4735
4736	sprintf(m_chBug, "Entity %i SubMesh %i, Material %s", nEntity, nSubMesh, chMaterial_Base) ;
4737	m_pLog->logMessage(m_chBug);
4738
4739
4740	// if the material is a lamp material we need to specify either an OpenGl or Direct3D version
4741	strcpy(chCompare, chMaterial_Base) ;
4742	chCompare[12]='\0' ;
4743	if(strcmp("lights/lamp_", chCompare)==0) // material is LAMP
4744	{
4745	if(m_IsOpenGL)
4746	strcat(chMaterial_Base, "_ogl") ;
4747	else
4748	strcat(chMaterial_Base, "_d3d") ;
4749
4750	}
4751
4752	strcpy(chCompare, chMaterial_Base) ;
4753	chCompare[17]='\0' ;
4754	if(strcmp("lights/lamp2pass_", chCompare)==0) // material is LAMP, 2 pass version
4755	{
4756	if(m_IsOpenGL)
4757	strcat(chMaterial_Base, "_ogl") ;
4758	else
4759	strcat(chMaterial_Base, "_d3d") ;
4760	}
4761
4762	// check that this material script exists, if not set to the default
4763	pMaterial_Base=MaterialManager::getSingleton().getByName(chMaterial_Base) ;
4764	if(true)//pMaterial_Base.isNull())
4765	{
4766	strcat(chMaterial_Base, " * MISSING *") ;
4767	// OFBug.LogAddCR(chMaterial_Base) ;
4768
4769	strcpy(chMaterial_Base, "textures/metaltech/OPAQUE_DSCE_TechRadar") ;
4770	pMaterial_Base=MaterialManager::getSingleton().getByName(chMaterial_Base) ;
4771	}
4772
4773
4774	// setup whether this material and it's entities are transparent or whatever
4775
4776	m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]=0 ;// default to nothing
4777
4778	if(strstr(chMaterial_Base, "OPAQUE")!=NULL) // material and its entity are OPAQUE
4779	{
4780	m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]=MAT_OPAQUE ; // note that the derived entity will be opaque
4781
4782	}
4783	else
4784	{
4785
4786	if(strstr(chMaterial_Base, "ALPHAPF")!=NULL) // material and its entity are ALPHAPF
4787	{
4788	m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]=MAT_OPAQUE ; // note that the derived entity will be opaque
4789	}
4790	else
4791	{
4792
4793	if(strstr(chMaterial_Base, "GEL")!=NULL) // material and its entity are GEL
4794	{
4795	m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]=MAT_GEL ; // note that the derived entity will be transparent
4796	}
4797	else
4798	{
4799
4800	strcpy(chCompare, chMaterial_Base) ;
4801	chCompare[12]='\0' ;
4802	if(strcmp("lights/lamp_", chCompare)==0) // material and its entity are LAMP (spotlights don't ever make triangles, only lamps)
4803	{
4804	m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]=MAT_LAMP ; // note that the derived entity will be lamp
4805	}
4806	else
4807	{
4808	strcpy(chCompare, chMaterial_Base) ;
4809	chCompare[17]='\0' ;
4810	if(strcmp("lights/lamp2pass_", chCompare)==0) // material and its entity are LAMP (spotlights don't ever make triangles, only lamps)
4811	{
4812	m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]=MAT_LAMP ; // note that the derived entity will be lamp
4813	}
4814	else
4815	{
4816
4817	if(strstr(chMaterial_Base, "GLOW_")!=NULL) // material and its entity are GLOW
4818	{
4819	m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]=MAT_GLOW ; // note that the derived entity will be glow
4820	}
4821	}
4822	}
4823	}
4824	}
4825	}
4826
4827
4828
4829
4830
4831	///////////////////////////////////////////////////////////////////////////////////////////////////////
4832	//
4833	// Setup the different material names and pointers needed for various passes
4834	//
4835	// Lamps need only one material, pMaterial_Base, which is already assigned above, so it skips all this.
4836	//
4837	// Glow needs two materials, pMaterial_Base plus pMaterial_DfShColour for the coloured gel deferred pass.
4838	// However it's better to make a third, and duplicate the pMaterial_Base to pMaterial_Emissive, since
4839	// when glow gets rendered on the Emmisive pass it would be odd to switch to the base material instead
4840	// of the emmisive.
4841	//
4842	// Other objects need multiple materials for various different deferred shading and FX passes
4843
4844	if((m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]!=MAT_LAMP) && (m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]!=MAT_GLOW))
4845	{
4846
4847	// material for fast shading
4848	strcpy(chMaterial_Fast, chMaterial_Base) ;
4849	strcat(chMaterial_Fast, "_Fast") ;
4850	pMaterial_Fast=MaterialManager::getSingleton().getByName(chMaterial_Fast) ;
4851	if(pMaterial_Fast.isNull())
4852	{
4853	sprintf(chMessage, "Missing material, using default: %s", chMaterial_Fast) ;
4854	m_pLog->logMessage(chMessage);
4855
4856	strcpy(chMaterial_Fast, "Fast") ;
4857	pMaterial_Fast=MaterialManager::getSingleton().getByName(chMaterial_Fast) ;
4858	}
4859
4860	// material for black shading
4861	strcpy(chMaterial_Black, chMaterial_Base) ;
4862	strcat(chMaterial_Black, "_Black") ;
4863	pMaterial_Black=MaterialManager::getSingleton().getByName(chMaterial_Black) ;
4864	if(pMaterial_Black.isNull())
4865	{
4866	// only issue a warning if this is an alpha testing material, others don't need specialized Black materials
4867	if(strstr(chMaterial_Base, "ALPHAPF")!=NULL)
4868	{
4869	sprintf(chMessage, "Missing material, using default: %s", chMaterial_Black) ;
4870	m_pLog->logMessage(chMessage);
4871	}
4872
4873	strcpy(chMaterial_Black, "Black") ;
4874	pMaterial_Black=MaterialManager::getSingleton().getByName(chMaterial_Black) ;
4875	}
4876
4877	// material for shadow casting
4878	strcpy(chMaterial_Shadow, chMaterial_Base) ;
4879	strcat(chMaterial_Shadow, "_Shadow") ;
4880	pMaterial_Shadow=MaterialManager::getSingleton().getByName(chMaterial_Shadow) ;
4881	if(pMaterial_Shadow.isNull())
4882	{
4883	strcpy(chMaterial_Shadow, "OPAQUE_Shadow") ;
4884	pMaterial_Shadow=MaterialManager::getSingleton().getByName(chMaterial_Shadow) ;
4885	}
4886
4887
4888
4889	// material for shadow casting
4890	strcpy(chMaterial_ShadeFront, chMaterial_Base) ;
4891	strcat(chMaterial_ShadeFront, "_ShadeFront") ;
4892	pMaterial_ShadeFront=MaterialManager::getSingleton().getByName(chMaterial_ShadeFront) ;
4893	if(pMaterial_ShadeFront.isNull())
4894	{
4895	// standard opaque ShadeFront.
4896	// Transparent surfaces MUST have their own _ShadeFront material or they will not colour light and can interfere with other trans surfaces.
4897	strcpy(chMaterial_ShadeFront, "OPAQUE_ShadeFront") ;
4898
4899	pMaterial_ShadeFront=MaterialManager::getSingleton().getByName(chMaterial_ShadeFront) ;
4900	}
4901
4902
4903	// material for shadow casting
4904	strcpy(chMaterial_ShadeBack, chMaterial_Base) ;
4905	strcat(chMaterial_ShadeBack, "_ShadeBack") ;
4906	pMaterial_ShadeBack=MaterialManager::getSingleton().getByName(chMaterial_ShadeBack) ;
4907	if(pMaterial_ShadeBack.isNull())
4908	{
4909	// standard opaque ShadeBack.
4910	// Transparent surfaces MUST have their own _ShadeBack material or they will not colour light and can interfere with other trans surfaces.
4911	strcpy(chMaterial_ShadeBack, "OPAQUE_ShadeBack") ;
4912
4913	pMaterial_ShadeBack=MaterialManager::getSingleton().getByName(chMaterial_ShadeBack) ;
4914	}
4915
4916	// material for deferred shading
4917	strcpy(chMaterial_DfShColour, chMaterial_Base) ;
4918	strcat(chMaterial_DfShColour, "_DfShColour") ;
4919	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
4920	if(pMaterial_DfShColour.isNull())
4921	{
4922	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShColour) ;
4923	m_pLog->logMessage(chMessage);
4924
4925	strcpy(chMaterial_DfShColour, "DfShColour") ;
4926	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
4927	}
4928
4929
4930	// material for deferred shading
4931	strcpy(chMaterial_DfShPosition, chMaterial_Base) ;
4932	strcat(chMaterial_DfShPosition, "_DfShPosition") ;
4933	pMaterial_DfShPosition=MaterialManager::getSingleton().getByName(chMaterial_DfShPosition) ;
4934	if(pMaterial_DfShPosition.isNull())
4935	{
4936	// only issue a warning if this is an alpha testing material, others don't need specialized DfShPosition materials
4937	if(strstr(chMaterial_Base, "ALPHAPF")!=NULL)
4938	{
4939	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShPosition) ;
4940	m_pLog->logMessage(chMessage);
4941	}
4942
4943	strcpy(chMaterial_DfShPosition, "DfShPosition") ;
4944	pMaterial_DfShPosition=MaterialManager::getSingleton().getByName(chMaterial_DfShPosition) ;
4945	}
4946
4947	// material for deferred shading
4948	strcpy(chMaterial_DfShDiffuse, chMaterial_Base) ;
4949	strcat(chMaterial_DfShDiffuse, "_DfShDiffuse") ;
4950	pMaterial_DfShDiffuse=MaterialManager::getSingleton().getByName(chMaterial_DfShDiffuse) ;
4951	if(pMaterial_DfShDiffuse.isNull())
4952	{
4953	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShDiffuse) ;
4954	m_pLog->logMessage(chMessage);
4955
4956	strcpy(chMaterial_DfShDiffuse, "DfShDiffuse") ;
4957	pMaterial_DfShDiffuse=MaterialManager::getSingleton().getByName(chMaterial_DfShDiffuse) ;
4958	}
4959
4960	/*
4961	// material for deferred shading // UNUSED
4962	strcpy(chMaterial_DSNormal, chMaterial_Base) ;
4963	strcat(chMaterial_DSNormal, "_DSNormal") ;
4964	pMaterial_DSNormal=MaterialManager::getSingleton().getByName(chMaterial_DSNormal) ;
4965	if(pMaterial_DSNormal.isNull())
4966	{
4967	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DSNormal) ;
4968	m_pLog->logMessage(chMessage);
4969
4970	strcpy(chMaterial_DSNormal, "DSNormal") ;
4971	pMaterial_DSNormal=MaterialManager::getSingleton().getByName(chMaterial_DSNormal) ;
4972	}
4973	*/
4974
4975	// material for deferred shading
4976	strcpy(chMaterial_DfShFuncTNB, chMaterial_Base) ;
4977	strcat(chMaterial_DfShFuncTNB, "_DfShFuncTNB") ;
4978	pMaterial_DfShFuncTNB=MaterialManager::getSingleton().getByName(chMaterial_DfShFuncTNB) ;
4979	if(pMaterial_DfShFuncTNB.isNull())
4980	{
4981	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShFuncTNB) ;
4982	m_pLog->logMessage(chMessage);
4983
4984	strcpy(chMaterial_DfShFuncTNB, "DfShFuncTNB") ;
4985	pMaterial_DfShFuncTNB=MaterialManager::getSingleton().getByName(chMaterial_DfShFuncTNB) ;
4986	}
4987
4988	// material for deferred shading
4989	strcpy(chMaterial_DfShSpecular, chMaterial_Base) ;
4990	strcat(chMaterial_DfShSpecular, "_DfShSpecular") ;
4991	pMaterial_DfShSpecular=MaterialManager::getSingleton().getByName(chMaterial_DfShSpecular) ;
4992	if(pMaterial_DfShSpecular.isNull())
4993	{
4994	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShSpecular) ;
4995	m_pLog->logMessage(chMessage);
4996
4997	strcpy(chMaterial_DfShSpecular, "DfShSpecular") ;
4998	pMaterial_DfShSpecular=MaterialManager::getSingleton().getByName(chMaterial_DfShSpecular) ;
4999	}
5000
5001	// material for deferred shading
5002	strcpy(chMaterial_DfShEmissive, chMaterial_Base) ;
5003	strcat(chMaterial_DfShEmissive, "_DfShEmissive") ;
5004	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
5005	if(pMaterial_DfShEmissive.isNull())
5006	{
5007	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShEmissive) ;
5008	m_pLog->logMessage(chMessage);
5009
5010	strcpy(chMaterial_DfShEmissive, "DfShEmissive") ;
5011	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
5012	}
5013
5014
5015	/*
5016	// material for deferred shading
5017	strcpy(chMaterial_DfShData, chMaterial_Base) ;
5018	strcat(chMaterial_DfShData, "_DfShData") ;
5019	pMaterial_DfShData=MaterialManager::getSingleton().getByName(chMaterial_DfShData) ;
5020	if(pMaterial_DfShData.isNull())
5021	{
5022	sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShData) ;
5023	m_pLog->logMessage(chMessage);
5024
5025	strcpy(chMaterial_DfShData, "DfShData") ;
5026	pMaterial_DfShData=MaterialManager::getSingleton().getByName(chMaterial_DfShData) ;
5027	}
5028	*/
5029
5030	// material for deferred shading
5031	strcpy(chMaterial_DfShMix, chMaterial_Base) ;
5032	strcat(chMaterial_DfShMix, "_DfShMix") ;
5033	pMaterial_DfShMix=MaterialManager::getSingleton().getByName(chMaterial_DfShMix) ;
5034	if(pMaterial_DfShMix.isNull())
5035	{
5036	// Pretty much all materials just use the default mix material,
5037	// so don't issue warnings if there isn't a specialized version
5038	//sprintf(chMessage, "Missing material, using default: %s", chMaterial_DfShMix) ;
5039	//m_pLog->logMessage(chMessage);
5040
5041	strcpy(chMaterial_DfShMix, "DfShMix") ;
5042	pMaterial_DfShMix=MaterialManager::getSingleton().getByName(chMaterial_DfShMix) ;
5043	}
5044
5045
5046
5047
5048
5049	}// end if not MAT_LAMP or MAT_GLOW
5050	else
5051	if(m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]==MAT_GLOW) // the two materials that glow needs
5052	{
5053
5054	// when I get around to allowing user defined GLOW materials as well as the automatic ones,
5055	// this'll be the place to add it.
5056	// For now, just the automatically generated lamp/light stuff has a glow.
5057
5058	// if the base material was "GLOW_lamp"
5059	strcpy(chCompare, chMaterial_Base) ;
5060	chCompare[strlen("GLOW_lamp")]='\0' ;
5061	if(strcmp("GLOW_lamp", chCompare)==0)
5062	{
5063	strcpy(chMaterial_DfShColour, "GLOW_lampcol") ;
5064	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
5065
5066	strcpy(chMaterial_DfShEmissive, "GLOW_lamp") ;
5067	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
5068	}
5069	else
5070	{
5071
5072	// if the base material was "GLOW_light"
5073	strcpy(chCompare, chMaterial_Base) ;
5074	chCompare[strlen("GLOW_light")]='\0' ;
5075	if(strcmp("GLOW_light", chCompare)==0)
5076	{
5077	strcpy(chMaterial_DfShColour, "GLOW_lightcol") ;
5078	pMaterial_DfShColour=MaterialManager::getSingleton().getByName(chMaterial_DfShColour) ;
5079
5080	strcpy(chMaterial_DfShEmissive, "GLOW_light") ;
5081	pMaterial_DfShEmissive=MaterialManager::getSingleton().getByName(chMaterial_DfShEmissive) ;
5082	}
5083
5084	}
5085	}
5086
5087
5088
5089
5090	// if the entity is a lamp or glow, set its material because they never get changed
5091	//if((m_pZoneEntityMaterialType[nMOIndex]==MAT_LAMP) \|\| (m_pZoneEntityMaterialType[nMOIndex]==MAT_GLOW))
5092	// m_pZoneEntity[nMOIndex]->setMaterial( pMaterial_Base) ;
5093
5094
5095	// store the pointers to the materials of this entity
5096	//m_pZoneEntityMaterial_Base[nMOIndex]=pMaterial_Base ;
5097	//m_pZoneEntityMaterial_Fast[nMOIndex]=pMaterial_Fast ;
5098	m_pEntityInfo[nEntity].Material_Black[nSubMesh]=pMaterial_Black ;
5099	m_pEntityInfo[nEntity].Material_DfShColour[nSubMesh]=pMaterial_DfShColour ;
5100	m_pEntityInfo[nEntity].Material_Shadow[nSubMesh]=pMaterial_Shadow ;
5101	m_pEntityInfo[nEntity].Material_ShadeFront[nSubMesh]=pMaterial_ShadeFront ;
5102	m_pEntityInfo[nEntity].Material_ShadeBack[nSubMesh]=pMaterial_ShadeBack ;
5103	m_pEntityInfo[nEntity].Material_DfShPosition[nSubMesh]=pMaterial_DfShPosition ;
5104	m_pEntityInfo[nEntity].Material_DfShDiffuse[nSubMesh]=pMaterial_DfShDiffuse ;
5105	//m_pEntityInfo[nEntity].Material_DSNormal[nSubMesh]=pMaterial_DSNormal ;
5106	m_pEntityInfo[nEntity].Material_DfShFuncTNB[nSubMesh]=pMaterial_DfShFuncTNB ;
5107	m_pEntityInfo[nEntity].Material_DfShSpecular[nSubMesh]=pMaterial_DfShSpecular ;
5108	m_pEntityInfo[nEntity].Material_DfShEmissive[nSubMesh]=pMaterial_DfShEmissive ;
5109	//m_pEntityInfo[nEntity].Material_DfShData[nSubMesh]=pMaterial_DfShData ;
5110	m_pEntityInfo[nEntity].Material_DfShMix[nSubMesh]=pMaterial_DfShMix ;
5111
5112
5113	//////////////////////////////////////////////////////////////////////////////////////////
5114
5115	char chNewName[1024] ;
5116	for(nPTex=0 ; nPTex<MAX_PROJECTORTEX ; nPTex++)
5117	{
5118	Ogre::AliasTextureNamePairList AliasList ;
5119
5120	// check the necessary texture exists
5121	//if(TextureManager::getSingleton().getByName(m_Q3Map->m_chSpotlightTexture[nPTex]).isNull())
5122	// OFBug.MessageInt(666) ;
5123
5124	AliasList.insert(AliasTextureNamePairList::value_type("projector_tex", m_Q3Map->m_chSpotlightTexture[nPTex]));
5125
5126	sprintf(chNewName, "%s_%i", chMaterial_Base, 0) ;
5127	m_pEntityInfo[nEntity].Material_Base[nPTex][nSubMesh]=pMaterial_Base->clone(chNewName) ;
5128	// change the texture unit
5129	m_pEntityInfo[nEntity].Material_Base[nPTex][nSubMesh]->applyTextureAliases(AliasList) ;
5130
5131	sprintf(chNewName, "%s_%i", chMaterial_Fast, 0) ;
5132	m_pEntityInfo[nEntity].Material_Fast[nPTex][nSubMesh]=pMaterial_Fast->clone(chNewName) ;
5133	// change the texture unit
5134	m_pEntityInfo[nEntity].Material_Fast[nPTex][nSubMesh]->applyTextureAliases(AliasList) ;
5135
5136	}
5137
5138	// create the sub scenenodes
5139	//sprintf(chSubNodeName, "Entity_%05i_%05i", nEntity, nSubMesh) ;
5140	//m_pEntityInfo[nEntity].pSubNode[nSubMesh]=m_pEntityInfo[nEntity].pMasterNode->createChildSceneNode(chSubNodeName) ;
5141
5142
5143	sprintf(m_chBug, "Node %s, Subnode %s, Type %i", chMasterNodeName, chSubNodeName, m_pEntityInfo[nEntity].SubMeshMaterialType[nSubMesh]) ;
5144	m_pLog->logMessage(m_chBug);
5145
5146	}// end for submesh
5147
5148	// build tangent vectors for the mesh
5149	m_pEntityInfo[nEntity].pEnt->getMesh()->suggestTangentVectorBuildParams(VES_TANGENT, src, dest) ;
5150	m_pEntityInfo[nEntity].pEnt->getMesh()->buildTangentVectors(VES_TANGENT, src, dest);
5151
5152
5153	// default to not active, not visible and in no zones
5154	m_pEntityInfo[nEntity].Active=0 ;
5155	m_pEntityInfo[nEntity].Visible=0 ;
5156	m_pEntityInfo[nEntity].Zone[INDEX_ENTITYZONECOUNT]=0 ;
5157
5158	// add some info about the bounding box
5159	Ogre::AxisAlignedBox aabb ;
5160	Ogre::Vector3 Minimum ;
5161	Ogre::Vector3 Maximum ;
5162
5163	aabb=m_pEntityInfo[nEntity].pEnt->getBoundingBox() ;
5164	Minimum=aabb.getMinimum() ;
5165	Maximum=aabb.getMaximum() ;
5166
5167	m_pEntityInfo[nEntity].AABB=aabb ;
5168	m_pEntityInfo[nEntity].Centre.x=(Maximum.x-Minimum.x)/2.0f ;
5169	m_pEntityInfo[nEntity].Centre.y=(Maximum.y-Minimum.y)/2.0f ;
5170	m_pEntityInfo[nEntity].Centre.z=(Maximum.z-Minimum.z)/2.0f ;
5171
5172	m_pEntityInfo[nEntity].AABBMin[0]=Minimum.x ;
5173	m_pEntityInfo[nEntity].AABBMin[1]=Minimum.y ;
5174	m_pEntityInfo[nEntity].AABBMin[2]=Minimum.z ;
5175	m_pEntityInfo[nEntity].AABBMax[0]=Maximum.x ;
5176	m_pEntityInfo[nEntity].AABBMax[1]=Maximum.y ;
5177	m_pEntityInfo[nEntity].AABBMax[2]=Maximum.z ;
5178
5179
5180	m_pEntityInfo[nEntity].Postition=Ogre::Vector3(0.0f, 0.0f, 0.0f) ;
5181
5182
5183
5184	return 1 ;
5185	}
5186
5187
5188	// Hmm... wanted to control some CG compiling, mainly to turn shadow filtering on or off, but I couln't get this to work.
5189	// I ended up just manually creating filtered and unfiltered version of the materials.
5190	/*
5191	int OgreFramework::ApplyCGDefines(void)
5192	{
5193	int nZoneMO=0 ;
5194	int nMaxZoneMO=m_nZoneMOStart[m_Q3Map->m_nMaxZone] ;
5195	int nPTex=0 ;
5196
5197	Ogre::Pass *CGPass ;
5198	int nPass=0 ;
5199	int nMaxPass=0 ;
5200
5201	for(nZoneMO=0 ; nZoneMO<nMaxZoneMO ; nZoneMO++)
5202	{
5203	//OFBug.MessageInt(nZoneMO, nMaxZoneMO, m_pZoneEntityMaterialType[nZoneMO]) ;
5204
5205	if(m_pZoneEntityMaterialType[nZoneMO]==MAT_OPAQUE)
5206	for(nPTex=0 ; nPTex<MAX_PROJECTORTEX ; nPTex++)
5207	{
5208	//m_pZoneEntityMaterial_Base[nPTex][nZoneMO]->getTechnique(0)->getPass(1)->getFragmentProgram()->setParameter("compile_arguments", "-DFILTER_ON 1") ;
5209	nMaxPass=m_pZoneEntityMaterial_Base[nPTex][nZoneMO]->getTechnique(0)->getNumPasses() ;
5210
5211	for(nPass=0 ; nPass<nMaxPass ; nPass++)
5212	{
5213	m_pZoneEntityMaterial_Base[nPTex][nZoneMO]->getTechnique(0)->getPass(nPass)->getFragmentProgram()->setParameter("compile_arguments", "-DFILTER_ON=1") ;
5214	//m_pZoneEntityMaterial_Base[nPTex][nZoneMO]->getTechnique(0)->getPass(nPass)->getFragmentProgram()->reload();
5215	}
5216	//CGPass=m_pZoneEntityMaterial_Base[nPTex][nZoneMO]->getTechnique(0)->getPass(0) ;
5217	}
5218	}
5219
5220
5221	//m_pZoneEntityMaterial_Base[0][0]->getTechnique(0)->getPass(1)->getFragmentProgram()->setParameter("compile_arguments", "-DFILTER_ON 1") ;
5222
5223
5224	return 1 ;
5225
5226
5227	}
5228	*/
5229
5230
5231	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5232	// create light manual objects, just for debugging/testing.
5233	// This is an array of manualobject AABBs that show the light culling box (double sided) for each light
5234
5235	int OgreFramework::AddLightCullingBoxes()
5236	{
5237	int nLt=0 ;
5238	// for calculating bounds of mesh
5239	float flMinX=0.0f ;
5240	float flMinY=0.0f ;
5241	float flMinZ=0.0f ;
5242	float flMaxX=0.0f ;
5243	float flMaxY=0.0f ;
5244	float flMaxZ=0.0f ;
5245	int nMaxLight=m_Q3Map->m_nLightMax ;
5246
5247	char chSceneNodeName[1024] ;
5248	char chManualName[1024] ;
5249
5250	m_pLightMO = new Ogre::ManualObject*[nMaxLight] ;
5251	if(m_pLightMO==NULL) return 0 ; // fail, out of mem
5252
5253	for(nLt=0 ; nLt<nMaxLight ; nLt++)
5254	{
5255
5256	sprintf(chManualName, "LightMO_%05i", nLt) ;
5257	m_pLightMO[nLt]=m_pSceneMgr->createManualObject(chManualName) ;
5258
5259	// start defining the manualObject
5260	m_pLightMO[nLt]->begin("lighttest", RenderOperation::OT_TRIANGLE_LIST) ;
5261
5262
5263	flMinX=m_Q3Map->m_pLight[nLt].Min[0] ;
5264	flMinY=m_Q3Map->m_pLight[nLt].Min[1] ;
5265	flMinZ=m_Q3Map->m_pLight[nLt].Min[2] ;
5266
5267	flMaxX=m_Q3Map->m_pLight[nLt].Max[0] ;
5268	flMaxY=m_Q3Map->m_pLight[nLt].Max[1] ;
5269	flMaxZ=m_Q3Map->m_pLight[nLt].Max[2] ;
5270
5271
5272	//////////////////////////////////////////////////////
5273	// back face
5274	m_pLightMO[nLt]->position(flMinX, flMaxY, flMinZ) ;
5275	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5276	m_pLightMO[nLt]->textureCoord(1.0, 0.0) ;
5277
5278	m_pLightMO[nLt]->position(flMaxX, flMaxY, flMinZ) ;
5279	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5280	m_pLightMO[nLt]->textureCoord(0.0, 0.0) ;
5281
5282	m_pLightMO[nLt]->position(flMaxX, flMinY, flMinZ) ;
5283	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5284	m_pLightMO[nLt]->textureCoord(0.0, 1.0) ;
5285
5286	m_pLightMO[nLt]->position(flMinX, flMinY, flMinZ) ;
5287	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5288	m_pLightMO[nLt]->textureCoord(1.0, 1.0) ;
5289
5290	m_pLightMO[nLt]->quad(0, 1, 2, 3) ;
5291	m_pLightMO[nLt]->quad(3, 2, 1, 0) ;
5292
5293	//////////////////////////////////////////////////////
5294	// front face
5295	m_pLightMO[nLt]->position(flMinX, flMaxY, flMaxZ) ;
5296	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5297	m_pLightMO[nLt]->textureCoord(0.0, 0.0) ;
5298
5299	m_pLightMO[nLt]->position(flMaxX, flMaxY, flMaxZ) ;
5300	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5301	m_pLightMO[nLt]->textureCoord(1.0, 0.0) ;
5302
5303	m_pLightMO[nLt]->position(flMaxX, flMinY, flMaxZ) ;
5304	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5305	m_pLightMO[nLt]->textureCoord(1.0, 1.0) ;
5306
5307	m_pLightMO[nLt]->position(flMinX, flMinY, flMaxZ) ;
5308	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5309	m_pLightMO[nLt]->textureCoord(0.0, 1.0) ;
5310
5311	m_pLightMO[nLt]->quad(7, 6, 5, 4) ;
5312	m_pLightMO[nLt]->quad(4, 5, 6, 7) ;
5313
5314	//////////////////////////////////////////////////////
5315	// left face
5316	m_pLightMO[nLt]->position(flMinX, flMaxY, flMaxZ) ;
5317	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5318	m_pLightMO[nLt]->textureCoord(1.0, 0.0) ;
5319
5320	m_pLightMO[nLt]->position(flMinX, flMaxY, flMinZ) ;
5321	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5322	m_pLightMO[nLt]->textureCoord(0.0, 0.0) ;
5323
5324	m_pLightMO[nLt]->position(flMinX, flMinY, flMinZ) ;
5325	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5326	m_pLightMO[nLt]->textureCoord(0.0, 1.0) ;
5327
5328	m_pLightMO[nLt]->position(flMinX, flMinY, flMaxZ) ;
5329	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5330	m_pLightMO[nLt]->textureCoord(1.0, 1.0) ;
5331
5332	m_pLightMO[nLt]->quad(8, 9, 10, 11) ;
5333	m_pLightMO[nLt]->quad(11, 10, 9, 8) ;
5334
5335
5336	//////////////////////////////////////////////////////
5337	// right face
5338	m_pLightMO[nLt]->position(flMaxX, flMaxY, flMaxZ) ;
5339	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5340	m_pLightMO[nLt]->textureCoord(0.0, 0.0) ;
5341
5342	m_pLightMO[nLt]->position(flMaxX, flMaxY, flMinZ) ;
5343	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5344	m_pLightMO[nLt]->textureCoord(1.0, 0.0) ;
5345
5346	m_pLightMO[nLt]->position(flMaxX, flMinY, flMinZ) ;
5347	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5348	m_pLightMO[nLt]->textureCoord(1.0, 1.0) ;
5349
5350	m_pLightMO[nLt]->position(flMaxX, flMinY, flMaxZ) ;
5351	m_pLightMO[nLt]->normal(0.0, 0.0, 1) ;
5352	m_pLightMO[nLt]->textureCoord(0.0, 1.0) ;
5353
5354	m_pLightMO[nLt]->quad(15, 14, 13, 12) ;
5355	m_pLightMO[nLt]->quad(12, 13, 14, 15) ;
5356
5357	//////////////////////////////////////////////////////
5358	// top face
5359	m_pLightMO[nLt]->position(flMinX, flMaxY, flMaxZ) ;
5360	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5361	m_pLightMO[nLt]->textureCoord(0.0, 1.0) ;
5362
5363	m_pLightMO[nLt]->position(flMaxX, flMaxY, flMaxZ) ;
5364	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5365	m_pLightMO[nLt]->textureCoord(1.0, 1.0) ;
5366
5367	m_pLightMO[nLt]->position(flMaxX, flMaxY, flMinZ) ;
5368	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5369	m_pLightMO[nLt]->textureCoord(1.0, 0.0) ;
5370
5371	m_pLightMO[nLt]->position(flMinX, flMaxY, flMinZ) ;
5372	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5373	m_pLightMO[nLt]->textureCoord(0.0, 0.0) ;
5374
5375	m_pLightMO[nLt]->quad(16, 17, 18, 19) ;
5376	m_pLightMO[nLt]->quad(19, 18, 17, 16) ;
5377
5378	//////////////////////////////////////////////////////
5379	// bottom face
5380	m_pLightMO[nLt]->position(flMinX, flMinY, flMaxZ) ;
5381	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5382	m_pLightMO[nLt]->textureCoord(0.0, 0.0) ;
5383
5384	m_pLightMO[nLt]->position(flMaxX, flMinY, flMaxZ) ;
5385	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5386	m_pLightMO[nLt]->textureCoord(1.0, 0.0) ;
5387
5388	m_pLightMO[nLt]->position(flMaxX, flMinY, flMinZ) ;
5389	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5390	m_pLightMO[nLt]->textureCoord(1.0, 1.0) ;
5391
5392	m_pLightMO[nLt]->position(flMinX, flMinY, flMinZ) ;
5393	m_pLightMO[nLt]->normal(0.0, 0.0, -1) ;
5394	m_pLightMO[nLt]->textureCoord(0.0, 1.0) ;
5395
5396	m_pLightMO[nLt]->quad(23, 22, 21, 20) ;
5397	m_pLightMO[nLt]->quad(20, 21, 22, 23) ;
5398	//////////////////////////////////////////////////////
5399
5400	m_pLightMO[nLt]->end() ;
5401
5402
5403
5404	sprintf(chSceneNodeName, "LSN%05i", nLt) ;
5405	m_pSceneMgr->getRootSceneNode()->createChildSceneNode(chSceneNodeName)->attachObject(m_pLightMO[nLt]) ;
5406
5407
5408	}
5409
5410	return 1 ;
5411	}
5412
5413	int OgreFramework::AddPortalBoxes()
5414	{
5415	int nPt=0 ;
5416	// for calculating bounds of mesh
5417	float flMinX=0.0f ;
5418	float flMinY=0.0f ;
5419	float flMinZ=0.0f ;
5420	float flMaxX=0.0f ;
5421	float flMaxY=0.0f ;
5422	float flMaxZ=0.0f ;
5423	int nMaxPortal=m_Q3Map->m_iNumPortals ;
5424
5425	char chSceneNodeName[1024] ;
5426	char chManualName[1024] ;
5427
5428	m_pPortalMO = new Ogre::ManualObject*[nMaxPortal] ;
5429	if(m_pPortalMO==NULL) return 0 ; // fail, out of mem
5430
5431	m_pPortalNode = new Ogre::Node*[nMaxPortal] ;
5432	if(m_pPortalNode==NULL)
5433	{
5434	//CHECKDELETE_ARRAY( m_pPortalMO ) ;
5435	return 0 ; // fail, out of mem
5436	}
5437
5438	for(nPt=0 ; nPt<nMaxPortal ; nPt++)
5439	{
5440
5441	sprintf(chManualName, "PortalMO_%05i", nPt) ;
5442	m_pPortalMO[nPt]=m_pSceneMgr->createManualObject(chManualName) ;
5443
5444	// start defining the manualObject
5445	m_pPortalMO[nPt]->begin("white", RenderOperation::OT_TRIANGLE_LIST) ;
5446
5447	flMinX=m_Q3Map->m_pPortals[nPt].Min[0] ;
5448	flMinY=m_Q3Map->m_pPortals[nPt].Min[1] ;
5449	flMinZ=m_Q3Map->m_pPortals[nPt].Min[2] ;
5450
5451	flMaxX=m_Q3Map->m_pPortals[nPt].Max[0] ;
5452	flMaxY=m_Q3Map->m_pPortals[nPt].Max[1] ;
5453	flMaxZ=m_Q3Map->m_pPortals[nPt].Max[2] ;
5454
5455
5456	//////////////////////////////////////////////////////
5457	// back face
5458	m_pPortalMO[nPt]->position(flMinX, flMaxY, flMinZ) ;
5459	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5460	m_pPortalMO[nPt]->textureCoord(1.0, 0.0) ;
5461
5462	m_pPortalMO[nPt]->position(flMaxX, flMaxY, flMinZ) ;
5463	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5464	m_pPortalMO[nPt]->textureCoord(0.0, 0.0) ;
5465
5466	m_pPortalMO[nPt]->position(flMaxX, flMinY, flMinZ) ;
5467	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5468	m_pPortalMO[nPt]->textureCoord(0.0, 1.0) ;
5469
5470	m_pPortalMO[nPt]->position(flMinX, flMinY, flMinZ) ;
5471	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5472	m_pPortalMO[nPt]->textureCoord(1.0, 1.0) ;
5473
5474	m_pPortalMO[nPt]->quad(0, 1, 2, 3) ;
5475	m_pPortalMO[nPt]->quad(3, 2, 1, 0) ;
5476
5477	//////////////////////////////////////////////////////
5478	// front face
5479	m_pPortalMO[nPt]->position(flMinX, flMaxY, flMaxZ) ;
5480	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5481	m_pPortalMO[nPt]->textureCoord(0.0, 0.0) ;
5482
5483	m_pPortalMO[nPt]->position(flMaxX, flMaxY, flMaxZ) ;
5484	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5485	m_pPortalMO[nPt]->textureCoord(1.0, 0.0) ;
5486
5487	m_pPortalMO[nPt]->position(flMaxX, flMinY, flMaxZ) ;
5488	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5489	m_pPortalMO[nPt]->textureCoord(1.0, 1.0) ;
5490
5491	m_pPortalMO[nPt]->position(flMinX, flMinY, flMaxZ) ;
5492	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5493	m_pPortalMO[nPt]->textureCoord(0.0, 1.0) ;
5494
5495	m_pPortalMO[nPt]->quad(7, 6, 5, 4) ;
5496	m_pPortalMO[nPt]->quad(4, 5, 6, 7) ;
5497
5498	//////////////////////////////////////////////////////
5499	// left face
5500	m_pPortalMO[nPt]->position(flMinX, flMaxY, flMaxZ) ;
5501	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5502	m_pPortalMO[nPt]->textureCoord(1.0, 0.0) ;
5503
5504	m_pPortalMO[nPt]->position(flMinX, flMaxY, flMinZ) ;
5505	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5506	m_pPortalMO[nPt]->textureCoord(0.0, 0.0) ;
5507
5508	m_pPortalMO[nPt]->position(flMinX, flMinY, flMinZ) ;
5509	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5510	m_pPortalMO[nPt]->textureCoord(0.0, 1.0) ;
5511
5512	m_pPortalMO[nPt]->position(flMinX, flMinY, flMaxZ) ;
5513	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5514	m_pPortalMO[nPt]->textureCoord(1.0, 1.0) ;
5515
5516	m_pPortalMO[nPt]->quad(8, 9, 10, 11) ;
5517	m_pPortalMO[nPt]->quad(11, 10, 9, 8) ;
5518
5519
5520	//////////////////////////////////////////////////////
5521	// right face
5522	m_pPortalMO[nPt]->position(flMaxX, flMaxY, flMaxZ) ;
5523	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5524	m_pPortalMO[nPt]->textureCoord(0.0, 0.0) ;
5525
5526	m_pPortalMO[nPt]->position(flMaxX, flMaxY, flMinZ) ;
5527	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5528	m_pPortalMO[nPt]->textureCoord(1.0, 0.0) ;
5529
5530	m_pPortalMO[nPt]->position(flMaxX, flMinY, flMinZ) ;
5531	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5532	m_pPortalMO[nPt]->textureCoord(1.0, 1.0) ;
5533
5534	m_pPortalMO[nPt]->position(flMaxX, flMinY, flMaxZ) ;
5535	m_pPortalMO[nPt]->normal(0.0, 0.0, 1) ;
5536	m_pPortalMO[nPt]->textureCoord(0.0, 1.0) ;
5537
5538	m_pPortalMO[nPt]->quad(15, 14, 13, 12) ;
5539	m_pPortalMO[nPt]->quad(12, 13, 14, 15) ;
5540
5541	//////////////////////////////////////////////////////
5542	// top face
5543	m_pPortalMO[nPt]->position(flMinX, flMaxY, flMaxZ) ;
5544	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5545	m_pPortalMO[nPt]->textureCoord(0.0, 1.0) ;
5546
5547	m_pPortalMO[nPt]->position(flMaxX, flMaxY, flMaxZ) ;
5548	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5549	m_pPortalMO[nPt]->textureCoord(1.0, 1.0) ;
5550
5551	m_pPortalMO[nPt]->position(flMaxX, flMaxY, flMinZ) ;
5552	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5553	m_pPortalMO[nPt]->textureCoord(1.0, 0.0) ;
5554
5555	m_pPortalMO[nPt]->position(flMinX, flMaxY, flMinZ) ;
5556	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5557	m_pPortalMO[nPt]->textureCoord(0.0, 0.0) ;
5558
5559	m_pPortalMO[nPt]->quad(16, 17, 18, 19) ;
5560	m_pPortalMO[nPt]->quad(19, 18, 17, 16) ;
5561
5562	//////////////////////////////////////////////////////
5563	// bottom face
5564	m_pPortalMO[nPt]->position(flMinX, flMinY, flMaxZ) ;
5565	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5566	m_pPortalMO[nPt]->textureCoord(0.0, 0.0) ;
5567
5568	m_pPortalMO[nPt]->position(flMaxX, flMinY, flMaxZ) ;
5569	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5570	m_pPortalMO[nPt]->textureCoord(1.0, 0.0) ;
5571
5572	m_pPortalMO[nPt]->position(flMaxX, flMinY, flMinZ) ;
5573	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5574	m_pPortalMO[nPt]->textureCoord(1.0, 1.0) ;
5575
5576	m_pPortalMO[nPt]->position(flMinX, flMinY, flMinZ) ;
5577	m_pPortalMO[nPt]->normal(0.0, 0.0, -1) ;
5578	m_pPortalMO[nPt]->textureCoord(0.0, 1.0) ;
5579
5580	m_pPortalMO[nPt]->quad(23, 22, 21, 20) ;
5581	m_pPortalMO[nPt]->quad(20, 21, 22, 23) ;
5582	//////////////////////////////////////////////////////
5583
5584	m_pPortalMO[nPt]->end() ;
5585
5586
5587
5588	sprintf(chSceneNodeName, "PSN%05i", nPt) ;
5589	m_pSceneMgr->getRootSceneNode()->createChildSceneNode(chSceneNodeName)->attachObject(m_pPortalMO[nPt]) ;
5590	m_pPortalNode[nPt]=m_pSceneMgr->getRootSceneNode()->getChild(chSceneNodeName) ;
5591
5592	}
5593
5594	return 1 ;
5595	}
5596
5597
5598
5599
5600
5601
5602
5603
5604
5605
5606
5607
5608
5609
5610
5611	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5612
5613
5614
5615
5616	// this function calculates which zones are visible.
5617	// If they are in the view frustum and any connecting portals are open, they're visible.
5618	// It calls a recursive functions that goes into each visible zone and scans it's portals
5619	// for more visible zones, cutting down the frustum as it goes.
5620	//
5621	// This function also checks which lights are visible.
5622	// First it scans the original zone the camera is in, any light whose centre is in that zone
5623	// is visible regardless of how many other zones that light touches.
5624	// Lights that are completely contained in any of the further zones are checked against the
5625	// current cut down frustum.
5626	void OgreFramework::CalculateZoneVisibility(Ogre::Camera pCamera, int pCameraZone, char* pZoneVis, char* pLightVis, char* pSubLightVis, char* pPortalVis, int* pMaxVisibleLight, unsigned short* pVisibleLightList)
5627	{
5628
5629
5630	int nZone=0 ;
5631	// int nZoneIndex=0 ;
5632	int nSubZone=0 ;
5633	// int nSubZoneIndex=0 ;
5634	int nMaxSubZone=0 ;
5635	int nPortal=0 ;
5636	// int nPortalIndex=0 ;
5637	int nMaxPortal=0 ;
5638	// int nMaxPortalZone=0 ;
5639	// int nPortalZone=0 ;
5640	// int nPortalZoneIndex=0 ;
5641	// int nMaxZone=0 ;
5642
5643
5644	int nMaxLight=m_Q3Map->m_nLightMax ;
5645	int nLt=0 ;
5646
5647	// int nMaxSubLight=m_Q3Map->m_nSubLightMax ;
5648	int nSubLt=0 ;
5649
5650	m_nMaxVisibleLight=0 ;
5651
5652
5653
5654	Ogre::Vector3 Pos=pCamera->getPosition() ;
5655	float flPos[3]={Pos.x, Pos.y, Pos.z} ;
5656
5657	Ogre::AxisAlignedBox AAB ;
5658
5659
5660
5661	// initially all lights are invisible
5662	// set all remaining real lights to invisible
5663	SetAllLightsOff() ;
5664
5665	m_nTotalTriangles=0 ;
5666
5667	*pMaxVisibleLight=0 ; // no lights in the list
5668
5669	if(m_nZoneCullingActive) // if zone culling is active
5670	{
5671
5672	// by default, all zones are not visible
5673	nZone=m_Q3Map->m_nMaxZone ;
5674	while(nZone)
5675	pZoneVis[--nZone]=ZONE_UNCHECKED ;
5676
5677	// by default, all lights are not visible
5678	nLt=nMaxLight ;
5679	while(nLt)
5680	pLightVis[--nLt]=LIGHT_UNCHECKED ;
5681
5682	// by default, all lights are not visible
5683	nSubLt=m_Q3Map->m_nSubLightMax ;
5684	while(nSubLt)
5685	pSubLightVis[--nSubLt]=LIGHT_UNCHECKED ;
5686
5687	// by default, all portals are not visible
5688	nPortal=m_Q3Map->m_iNumPortals ;
5689	while(nPortal)
5690	pPortalVis[--nPortal]=PORTAL_UNCHECKED ;
5691	}
5692	else
5693	{
5694	// for debugging, all zones are visible
5695	nZone=m_Q3Map->m_nMaxZone ;
5696	while(nZone)
5697	pZoneVis[--nZone]=ZONE_VISIBLE ;
5698
5699
5700	// by default, all lights are visible
5701	nLt=nMaxLight ;
5702	while(nLt)
5703	pLightVis[--nLt]=LIGHT_VISIBLE ;
5704
5705	nSubLt=m_Q3Map->m_nSubLightMax ;
5706	while(nSubLt)
5707	pSubLightVis[--nSubLt]=LIGHT_VISIBLE ;
5708
5709	// by default, all portals are visible
5710	nPortal=m_Q3Map->m_iNumPortals ;
5711	while(nPortal)
5712	pPortalVis[--nPortal]=PORTAL_VISIBLE ;
5713
5714	return ;
5715	}
5716
5717
5718
5719
5720
5721
5722
5723
5724	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
5725
5726
5727
5728	/////////////////////////////////////////////////////////////////////////////////////
5729	// check camera is actually in the zone designated, otherwise update it.
5730
5731	if((pCameraZone==-1) \|\| (!m_Q3Map->PointInZone(flPos, pCameraZone)) )
5732	{
5733
5734	nSubZone=m_Q3Map->GetNextSubZone(flPos, -1, m_Q3Map->m_iNumSubZones) ;
5735
5736	// subzone might still be -1 if the point isn't in any zone. If this happens, set all zones in the view frustum as visible.
5737	// this shouldn't generally happen, but if we aren't clipping and are flying around testing, it can.
5738	// Don't worry about optimizing this.
5739
5740
5741
5742	if(nSubZone==-1)
5743	{
5744
5745	nMaxSubZone=m_Q3Map->m_iNumSubZones ;
5746	for(nSubZone=0 ; nSubZone<nMaxSubZone ; nSubZone++)
5747	{
5748	AAB.setExtents(m_Q3Map->m_pSubZones[nSubZone].Min[0], m_Q3Map->m_pSubZones[nSubZone].Min[1], m_Q3Map->m_pSubZones[nSubZone].Min[2], m_Q3Map->m_pSubZones[nSubZone].Max[0], m_Q3Map->m_pSubZones[nSubZone].Max[1], m_Q3Map->m_pSubZones[nSubZone].Max[2]) ;
5749
5750	if(pCamera->isVisible(AAB))
5751	pZoneVis[ m_Q3Map->m_pSubZones[nSubZone].Zone ]=ZONE_VISIBLE ;
5752	}
5753
5754	*pCameraZone=-1 ;
5755	return ; // skip everything else
5756	}
5757
5758	*pCameraZone=m_Q3Map->m_pSubZones[nSubZone].Zone ; // update the zone
5759
5760	}
5761
5762	//
5763	/////////////////////////////////////////////////////////////////////////////////////
5764
5765
5766	// update the portal states
5767	nMaxPortal=m_Q3Map->m_iNumPortals ;
5768	nPortal=nMaxPortal ;
5769	while(nPortal)
5770	{
5771	nPortal-- ;
5772
5773	if(m_nPortalDebug==0)
5774	m_chPortalState[nPortal]=PORTALSTATE_OPEN ;
5775	else
5776	{
5777	//if(m_nPortalState==1)
5778	m_chPortalState[nPortal]=PORTALSTATE_OPEN ;
5779	//else
5780	// m_chPortalState[nPortal]=PORTALSTATE_CLOSED ;
5781
5782
5783
5784	}
5785
5786	//m_chPortalState[nPortal]\|=PORTAL_FLAG_UNCHECKED ; // by default all portals are unchecked
5787
5788	//m_chPortalState[nPortal]&=~(PORTAL_FLAG_VISCHECK\|PORTAL_FLAG_VISIBLE) ; // by default, all portals are vis unchecked and not visible
5789	}
5790
5791	//m_chPortalState[0]=PORTAL_FLAG_CLOSED ;
5792	if(m_nPortalState==1)
5793	m_chPortalState[1]=PORTALSTATE_OPEN ;
5794	else
5795	m_chPortalState[1]=PORTALSTATE_CLOSED ;
5796
5797
5798
5799
5800	//Ogre::Camera* pTestCamera ;
5801	//pTestCamera->synchroniseBaseSettingsWith(pCamera) ;
5802
5803	//Ogre::Real OrigL, OrigR, OrigT, OrigB ; // original frustum extents
5804	//pCamera->getFrustumExtents(OrigL, OrigR, OrigT, OrigB) ;
5805
5806	//pCamera->setFrustumExtents(OrigL/2.0, OrigR/2.0, OrigT/2.0, OrigB/2.0) ; // reset the original frustum extents
5807
5808	m_nRecurseCount=0 ;
5809
5810
5811	// work out the aspect scaling we'll need
5812	Ogre::Real OrigL, OrigR, OrigT, OrigB, ScaleX, ScaleY ; // frustum extents per each portal in this zone
5813	Ogre::Real NewL, NewR, NewT, NewB ;
5814	pCamera->getFrustumExtents(OrigL, OrigR, OrigT, OrigB) ;
5815
5816	m_ViewMatrix=pCamera->getViewMatrix(true) ;
5817	m_ProjectionMatrix=pCamera->getProjectionMatrix() ;
5818
5819
5820	//if(m_nOriginalZoneOpenPortals=0) // no portals on player zone are open, so we can only see the current zones.
5821	// pZoneVis[nZone]=ZONE_VISIBLE ; // flag this subzone as visible
5822	//else
5823	{
5824
5825	/*
5826	// apply the stereofrustum tweak if needed
5827	if(m_flStereoFrustumTweak!=0.0f)
5828	{
5829
5830	NewL=OrigL-m_flStereoFrustumTweak ;
5831	NewR=OrigR+m_flStereoFrustumTweak ;
5832	NewT=OrigT ;
5833	NewB=OrigB ;
5834	pCamera->setFrustumExtents(NewL, NewR, NewT, NewB) ;
5835	}
5836	else
5837	*/
5838	{
5839	NewL=OrigL ;
5840	NewR=OrigR ;
5841	NewT=OrigT ;
5842	NewB=OrigB ;
5843	}
5844
5845	ScaleX=NewR ;
5846	ScaleY=NewT ;
5847
5848
5849	PortalScan(pCamera, *pCameraZone, ScaleX, ScaleY, pZoneVis, pLightVis, pSubLightVis, pPortalVis, pMaxVisibleLight, pVisibleLightList) ; // recursively scan portals and work out zone visibility
5850
5851
5852	pCamera->setFrustumExtents(OrigL, OrigR, OrigT, OrigB) ; // reset the original frustum extents
5853
5854	CheckMultiZoneLights(*pCameraZone, pZoneVis, pLightVis, pSubLightVis) ;
5855	AddZonesFromMultiZoneLights(pZoneVis, pLightVis, pSubLightVis) ;
5856
5857	// check entity visibility
5858
5859
5860	}
5861
5862
5863
5864
5865
5866
5867
5868
5869	}
5870
5871
5872	void OgreFramework::SetupEntityZones(void)
5873	{
5874	// work out what zones any active entities are in.
5875	int nEntity=0 ;
5876	float Centre[3] ;
5877	float AABBMin[3] ;
5878	float AABBMax[3] ;
5879	float* pLightMin ;
5880	float* pLightMax ;
5881
5882	int nOldZone=0 ;
5883	int nCurrentZone=0 ;
5884	int nMaxOldZone=0 ;
5885	int nZonePerZoneIndex=0 ;
5886	int nZone=0 ;
5887	int nZoneIndex=0 ;
5888	int nMaxZone=0 ;
5889	int nMaxSubLightIndex=0 ;
5890	int nSubLightIndex=0 ;
5891	int nSubLight=0 ;
5892
5893	// int nLight=0;
5894	int nLightIndex=0 ;
5895
5896
5897
5898
5899	for(nEntity=0 ; nEntity<m_nMaxEntity ; nEntity++)
5900	if(m_pEntityInfo[nEntity].Active)
5901	{
5902	nLightIndex=0 ;
5903	// to calculate what zones an entity is in, we test the centre of it's bounding box to get the main zone.
5904	// we then test all zones that touch the central zone and see if they touch the entity bounding box.
5905
5906	// check if the entity central point is still in the same zone as last time.
5907	Centre[0]=m_pEntityInfo[nEntity].Centre.x + m_pEntityInfo[nEntity].Postition.x ;
5908	Centre[1]=m_pEntityInfo[nEntity].Centre.y + m_pEntityInfo[nEntity].Postition.y ;
5909	Centre[2]=m_pEntityInfo[nEntity].Centre.z + m_pEntityInfo[nEntity].Postition.z ;
5910
5911	nMaxOldZone=m_pEntityInfo[nEntity].Zone[INDEX_ENTITYZONECOUNT] ;
5912
5913
5914
5915	if(nMaxOldZone>0)
5916	{
5917	nOldZone=m_pEntityInfo[nEntity].Zone[0] ;
5918	if(m_Q3Map->PointInZone(Centre, nOldZone))
5919	nCurrentZone=nOldZone ; // still in the same zone as last round
5920	else
5921	{
5922	// see if we are in one of the other zones that were touched by this entity's aabb last round
5923
5924	nCurrentZone=-1 ;
5925	for(nZoneIndex=1 ; nZoneIndex<nMaxOldZone ; nZoneIndex++)
5926	{
5927	if(m_Q3Map->PointInZone(Centre, m_pEntityInfo[nEntity].Zone[nZoneIndex]))
5928	{
5929	nCurrentZone=m_pEntityInfo[nEntity].Zone[nZoneIndex] ; // found the current zone we are in
5930	break ;
5931	}// end if point in zone
5932
5933	}// end for zoneindex
5934
5935	}// end if not in old zone.
5936	}
5937	else
5938	nCurrentZone=-1 ;
5939
5940
5941	// if we haven't found the current zone so far, we need to check every zone.
5942	if(nCurrentZone==-1)
5943	{
5944	nZone=m_Q3Map->m_nMaxZone ;
5945	while(nZone)
5946	if(m_Q3Map->PointInZone(Centre, --nZone))
5947	{
5948	nCurrentZone=nZone ;
5949	break ;
5950	}
5951	}// end if nCurrentZone -1
5952
5953
5954
5955	// now either nCurrentZone is the zone the central point is in, or the entity isn't in any zone
5956	if(nCurrentZone==-1)
5957	m_pEntityInfo[nEntity].Zone[INDEX_ENTITYZONECOUNT]=0 ;
5958	else
5959	{
5960	// scan through all the zones that touch this entitys central zone
5961	// see if the entitys AABB touches those other zones.
5962	m_pEntityInfo[nEntity].Zone[0]=nCurrentZone ;
5963	nZonePerZoneIndex=1 ;
5964
5965	AABBMin[0]=m_pEntityInfo[nEntity].Postition.x + m_pEntityInfo[nEntity].AABBMin[0] ;
5966	AABBMin[1]=m_pEntityInfo[nEntity].Postition.y + m_pEntityInfo[nEntity].AABBMin[1] ;
5967	AABBMin[2]=m_pEntityInfo[nEntity].Postition.z + m_pEntityInfo[nEntity].AABBMin[2] ;
5968
5969	AABBMax[0]=m_pEntityInfo[nEntity].Postition.x + m_pEntityInfo[nEntity].AABBMax[0] ;
5970	AABBMax[1]=m_pEntityInfo[nEntity].Postition.y + m_pEntityInfo[nEntity].AABBMax[1] ;
5971	AABBMax[2]=m_pEntityInfo[nEntity].Postition.z + m_pEntityInfo[nEntity].AABBMax[2] ;
5972
5973
5974	nMaxZone=m_Q3Map->m_nZoneTouchesZone[nCurrentZone][INDEX_ZONEPERZONECOUNT] ;
5975	for(nZoneIndex=0 ; nZoneIndex<nMaxZone ; nZoneIndex++)
5976	{
5977	nZone=m_Q3Map->m_nZoneTouchesZone[nCurrentZone][nZoneIndex] ;
5978
5979	if(m_Q3Map->AABBTouchesZone(AABBMin, AABBMax, nZone))
5980	{
5981	m_pEntityInfo[nEntity].Zone[nZonePerZoneIndex]=nZone ;
5982	nZonePerZoneIndex++ ;
5983
5984	if(nZonePerZoneIndex>MAX_ZONEPERENTITY)
5985	nZonePerZoneIndex=MAX_ZONEPERENTITY ;
5986	}
5987
5988
5989
5990	}// end for nZoneIndex
5991
5992
5993	m_pEntityInfo[nEntity].Zone[INDEX_ENTITYZONECOUNT]=nZonePerZoneIndex ;
5994
5995	// go through all the zones and check which lights touch this entity AABB
5996	for(nZoneIndex=0 ; nZoneIndex<nZonePerZoneIndex ; nZoneIndex++)
5997	{
5998	nZone=m_pEntityInfo[nEntity].Zone[nZoneIndex] ;
5999
6000	nMaxSubLightIndex=m_Q3Map->m_nZoneTouchesSubLight[nZone][MAX_LIGHTPERZONE] ;
6001	for(nSubLightIndex=0 ; nSubLightIndex<nMaxSubLightIndex ; nSubLightIndex++)
6002	{
6003	nSubLight=m_Q3Map->m_nZoneTouchesSubLight[nZone][nSubLightIndex] ;
6004	pLightMin=m_Q3Map->m_SubLight[nSubLight].Min ;
6005	pLightMax=m_Q3Map->m_SubLight[nSubLight].Max ;
6006
6007	// if the entity overlaps the sublight
6008	if(
6009	(AABBMin[0]<pLightMax[0]) && (AABBMax[0]>pLightMin[0])
6010	&& (AABBMin[1]<pLightMax[1]) && (AABBMax[1]>pLightMin[1])
6011	&& (AABBMin[2]<pLightMax[2]) && (AABBMax[2]>pLightMin[2])
6012	)
6013	{
6014	// add this to the list of lights.
6015	// it's possible it might get listed more than once if this is a multizone light, that's ok.
6016
6017	m_pEntityInfo[nEntity].Light[nLightIndex]=m_Q3Map->m_SubLight[nSubLight].Light ;
6018	nLightIndex++ ;
6019	if(nLightIndex>MAX_LIGHTPERENTITY)
6020	nLightIndex=MAX_LIGHTPERENTITY ;
6021
6022
6023	} // end if overlap
6024
6025	}// end for nSubLightIndex
6026
6027	}// end for nZoneIndex
6028
6029	}// end if we have a central zone
6030
6031
6032	m_pEntityInfo[nEntity].Light[INDEX_LIGHTPERENTITY]=nLightIndex ;
6033
6034
6035	}// end if entity is active
6036	}
6037
6038	// spotlights need entities set as visible if they are in a visible zone, even if they aren't in the frustum,
6039	// because they might cast shadows that are in the frustum.
6040	// However the deferred render only needs consider entities which are in a visible zone AND in the frustum.
6041	// m_pVisibleEntity holds entities in visible zones,
6042	// m_pFrustumEntity holds entities in visible zones that are also in the view frustum.
6043	void OgreFramework::CalculateEntityVisibility(Ogre::Camera* pCamera, char* pZoneVis)
6044	{
6045
6046	int nEntity=0 ;
6047	int nMaxZone=0 ;
6048	int nZone=0 ;
6049	int nZoneIndex=0 ;
6050	// int nVisible=0 ;
6051	Ogre::AxisAlignedBox AABB ;
6052
6053
6054	m_nMaxVisibleEntity=0 ; // default to an empty list
6055	m_nMaxFrustumEntity=0 ; // default to an empty list
6056
6057	m_nVisibleEntityTriangleCount=0 ;
6058	m_nFrustumEntityTriangleCount=0 ;
6059
6060	for(nEntity=0 ; nEntity<m_nMaxEntity ; nEntity++)
6061	if(m_pEntityInfo[nEntity].Active)
6062	{
6063	m_pEntityInfo[nEntity].Visible=0 ; // default to not visible
6064	m_pEntityInfo[nEntity].Frustum=0 ; // default to not visible and not in frustum
6065
6066	nMaxZone=m_pEntityInfo[nEntity].Zone[INDEX_ENTITYZONECOUNT] ;
6067
6068
6069
6070	for(nZoneIndex=0 ; nZoneIndex<nMaxZone ; nZoneIndex++)
6071	{
6072	nZone=m_pEntityInfo[nEntity].Zone[nZoneIndex] ;
6073
6074	// if a zone this entity touches is visible, test if it is in the view frustrum
6075	if(pZoneVis[nZone]==ZONE_VISIBLE)
6076	{
6077
6078	m_pEntityInfo[nEntity].Visible=1 ;
6079	m_nVisibleEntityTriangleCount+=m_pEntityInfo[nEntity].TriangleCount ;
6080	m_pVisibleEntity[m_nMaxVisibleEntity++]=nEntity ;
6081
6082
6083	// is this entity also in the view frustum?
6084	AABB.setMinimum( m_pEntityInfo[nEntity].AABB.getMinimum() + m_pEntityInfo[nEntity].Postition ) ;
6085	AABB.setMaximum( m_pEntityInfo[nEntity].AABB.getMaximum() + m_pEntityInfo[nEntity].Postition ) ;
6086
6087	if(pCamera->isVisible(AABB))
6088	{
6089	m_pEntityInfo[nEntity].Frustum=1 ;
6090	m_nFrustumEntityTriangleCount+=m_pEntityInfo[nEntity].TriangleCount ;
6091	m_pFrustumEntity[m_nMaxFrustumEntity++]=nEntity ;
6092	}
6093
6094
6095
6096
6097
6098	break ; // get out of the loop, we know the entity is visible.
6099
6100	}// end if zone is visible
6101
6102	}// end for nZoneIndex
6103
6104	}// end if entity is active
6105
6106	}
6107
6108
6109
6110
6111
6112	void OgreFramework::SetAllLightsOff(void)
6113	{
6114	Light *light;
6115	char chLightName[1024] ;
6116	int nLt=0 ;
6117	for(nLt=0 ; nLt<MAXLIGHTPERLOOP ; nLt++)
6118	{
6119	sprintf(chLightName, "LT%02i", nLt) ;
6120	light=m_pSceneMgr->getLight(chLightName) ;
6121	light->setVisible(false) ;
6122	}
6123	}
6124
6125	void OgreFramework::SetSingleVisibleLight(int nLt, bool bOn)
6126	{
6127	Light *light;
6128
6129	light=m_pSceneMgr->getLight("LT00") ;
6130
6131
6132	// if we're just turning the light off, make it invisible and return.
6133	if(bOn==false)
6134	{
6135	light->setVisible(false) ;
6136	return ;
6137	}
6138
6139
6140
6141	light->setDiffuseColour(Ogre::ColourValue(1,1,1));
6142	light->setSpecularColour(Ogre::ColourValue(1,1,1));
6143
6144	light->setAttenuation(m_Q3Map->m_pLight[nLt].Cutoff, 1.0, 1.0, 0.005);
6145	light->setPosition(Ogre::Vector3(m_Q3Map->m_pLight[nLt].Position[0], m_Q3Map->m_pLight[nLt].Position[1], m_Q3Map->m_pLight[nLt].Position[2]));
6146	light->setDirection(Ogre::Vector3(m_Q3Map->m_pLight[nLt].Direction[0], m_Q3Map->m_pLight[nLt].Direction[1], m_Q3Map->m_pLight[nLt].Direction[2]));
6147
6148	light->setSpotlightRange(Degree(m_Q3Map->m_pLight[nLt].Angle-5.0), Degree(m_Q3Map->m_pLight[nLt].Angle), 1.0) ;
6149	light->setVisible(true) ;
6150	}
6151
6152
6153	// sets up a single visible light from the visible light list and assigns the camera to its position and settings
6154	// returns true if successful, false if not (such as if the light isn't actually visible)
6155
6156	bool OgreFramework::SetupSingleVisibleLightAndShadowCamera(int nLt, char* pLightVis, unsigned short* pVisibleLightList, Ogre::Camera* pCamera)
6157	{
6158	//if(nLt!=4) return false ;
6159
6160	if((pLightVis[nLt]&LIGHT_VISIBLE)==0) // we need to check this again, since there's a chance a multi-zone light might have been culled at the last stage
6161	return false ;
6162
6163
6164	Light *light=m_pSceneMgr->getLight("LT00") ;
6165
6166	light->setDiffuseColour(Ogre::ColourValue(m_Q3Map->m_pLight[nLt].Colour[0], m_Q3Map->m_pLight[nLt].Colour[1], m_Q3Map->m_pLight[nLt].Colour[2]));
6167
6168	float flRange=m_Q3Map->m_pLight[nLt].Cutoff ; // set the range
6169	if(flRange<10240.0) //!! Ogre seems to cut off lights wrongly if the range is low, so set it to a minimum.
6170	flRange=10240 ;
6171
6172	// The light attenuation parameters have been co-opted by me... they no longer represent range, constant, linear, quadratic
6173	// instead,
6174	// first parameter is the above range, just set high so Ogre doesn't turn lights off itself. The shaders ignore this parameter.
6175	// second parameter is the cutoff used in the shader. Light suddenly cuts off after this distance.
6176	// third parameter is the brightness. This controls the quadratic falloff of the light.
6177	// fourth parameter is unused, leave as 1.0 for now.
6178
6179	light->setAttenuation(flRange, m_Q3Map->m_pLight[nLt].Cutoff, m_Q3Map->m_pLight[nLt].Brightness, 1.0) ;
6180
6181
6182
6183	// Ogre uses a fixed yaw axis which will cause pCamera->setDirection to malfunction if we point directly up or down.
6184	// To avoid this we need to check for such lights and shift their direction a little.
6185
6186	float DirX=m_Q3Map->m_pLight[nLt].Direction[0] ;
6187	float DirY=m_Q3Map->m_pLight[nLt].Direction[1] ;
6188	float DirZ=m_Q3Map->m_pLight[nLt].Direction[2] ;
6189
6190
6191	if((DirY>1.0-CAMERA_EPSILON) && (DirY<1.0+CAMERA_EPSILON)) // camera is pointing directly up
6192	{
6193	DirX=0.0f ;
6194	DirY=1.0f ;
6195	DirZ=0.000001f ;
6196	}
6197	else
6198	if((DirY>-1.0-CAMERA_EPSILON) && (DirY<-1.0+CAMERA_EPSILON)) // camera is pointing directly down
6199	{
6200	DirX=0.0f ;
6201	DirY=-1.0f ;
6202	DirZ=0.000001f ;
6203	}
6204
6205	light->setPosition(Ogre::Vector3(m_Q3Map->m_pLight[nLt].Position[0], m_Q3Map->m_pLight[nLt].Position[1], m_Q3Map->m_pLight[nLt].Position[2]));
6206	light->setDirection(Ogre::Vector3(DirX, DirY, DirZ));
6207
6208	light->setSpotlightRange(Degree(m_Q3Map->m_pLight[nLt].Angle-5.0), Degree(m_Q3Map->m_pLight[nLt].Angle), 1.0) ;
6209	light->setVisible(true) ;
6210
6211	// setup the camera
6212	pCamera->setAspectRatio(1) ;
6213	pCamera->yaw(Ogre::Radian(0)) ;
6214	pCamera->roll(Ogre::Radian(0)) ;
6215	pCamera->pitch(Ogre::Radian(0)) ;
6216	pCamera->setPosition(m_Q3Map->m_pLight[nLt].Position[0], m_Q3Map->m_pLight[nLt].Position[1], m_Q3Map->m_pLight[nLt].Position[2]) ;
6217	pCamera->setDirection(DirX, DirY, DirZ) ;
6218	pCamera->setFOVy( Degree(m_Q3Map->m_pLight[nLt].Angle ) ) ;
6219
6220	return true ;
6221
6222	}
6223
6224
6225	void OgreFramework::UpdateVisibleZoneList(char* pZoneVis, unsigned short* pVisibleZoneList, int* pMaxVisibleZone)
6226	{
6227	int nZone=0 ;
6228	int nMaxVisibleZone=0 ;
6229
6230	for(nZone=0 ; nZone<m_Q3Map->m_nMaxZone ; nZone++)
6231	if(pZoneVis[nZone]==ZONE_VISIBLE)
6232	pVisibleZoneList[nMaxVisibleZone++]=nZone ;
6233
6234	*pMaxVisibleZone=nMaxVisibleZone ;
6235
6236	}
6237
6238	void OgreFramework::SetZoneNodeAttachments(unsigned short* pVisibleZoneList, int* pMaxVisibleZone, int nMaterialFlags)
6239	{
6240
6241	int nListPos=0 ;
6242	int nZone=0 ;
6243	int nMaxListPos=*pMaxVisibleZone ;
6244
6245
6246
6247	for(nListPos=0 ; nListPos<nMaxListPos ; nListPos++)
6248	{
6249	nZone=pVisibleZoneList[nListPos] ;
6250
6251	// if the zone node is not already attached, attach it.
6252
6253	if( m_nOpaqueNodeUsed[nZone] && (nMaterialFlags&MAT_OPAQUE) && !m_pOpaqueNode[nZone]->isInSceneGraph() )
6254	m_pSceneMgr->getRootSceneNode()->addChild(m_pOpaqueNode[nZone]) ;
6255
6256	if( m_nTransNodeUsed[nZone] && (nMaterialFlags&MAT_GEL) && !m_pTransNode[nZone]->isInSceneGraph() )
6257	m_pSceneMgr->getRootSceneNode()->addChild(m_pTransNode[nZone]) ;
6258
6259	if( m_nLampNodeUsed[nZone] && (nMaterialFlags&MAT_LAMP) && !m_pLampNode[nZone]->isInSceneGraph() )
6260	m_pSceneMgr->getRootSceneNode()->addChild(m_pLampNode[nZone]) ;
6261
6262	if( m_nGlowNodeUsed[nZone] && (nMaterialFlags&MAT_GLOW) && !m_pGlowNode[nZone]->isInSceneGraph() )
6263	m_pSceneMgr->getRootSceneNode()->addChild(m_pGlowNode[nZone]) ;
6264
6265	}
6266
6267
6268
6269	/*
6270	if(m_nDebugLightBox)
6271	{
6272	int nLt=0 ;
6273	int nMaxLight=m_Q3Map->m_nLightMax ;
6274
6275	for(nLt=0 ; nLt<nMaxLight ; nLt++)
6276	if(m_chLightVis[nLt]==LIGHT_VISIBLE)
6277	{
6278	m_pLightMO[nLt]->setVisible(true) ;
6279
6280	}
6281	else
6282	m_pLightMO[nLt]->setVisible(false) ;
6283
6284
6285
6286	}
6287
6288	if(m_nPortalDebug)
6289	{
6290	int nPt=0 ;
6291	int nMaxPortal=m_Q3Map->m_iNumPortals ;
6292
6293	for(nPt=0 ; nPt<nMaxPortal ; nPt++)
6294	if(
6295	(m_chPortalVis[nPt]&PORTAL_VISIBLE)
6296	&&
6297	(m_chPortalState[nPt]&PORTALSTATE_CLOSED)
6298	)
6299	m_pPortalMO[nPt]->setVisible(true) ;
6300	else
6301	m_pPortalMO[nPt]->setVisible(false) ;
6302	}
6303
6304	*/
6305	}
6306
6307
6308	void OgreFramework::SetZoneNodeAttachments(unsigned short* pVisibleZoneList, int* pMaxVisibleZone, int nMaterialFlags, int nLight)
6309	{
6310
6311	nLight=IGNORE_LIGHT ;
6312
6313	int nListPos=0 ;
6314	int nZone=0 ;
6315	int nMaxListPos=*pMaxVisibleZone ;
6316
6317	int nLightZone=0 ;
6318	int nMaxLightZone=0 ;
6319	int nFoundZone=0 ;
6320
6321
6322	for(nListPos=0 ; nListPos<nMaxListPos ; nListPos++)
6323	{
6324	nZone=pVisibleZoneList[nListPos] ;
6325
6326	// is this zone touched by this light?
6327	if(nLight!=IGNORE_LIGHT)
6328	{
6329	nMaxLightZone=m_Q3Map->m_nLightTouchesZone[nLight][INDEX_LIGHTZONECOUNT] ;
6330
6331	nFoundZone=0 ;
6332	for(nLightZone=0 ; nLightZone<nMaxLightZone ; nLightZone++)
6333	if(m_Q3Map->m_nLightTouchesZone[nLight][nLightZone]==nZone)
6334	{
6335	nFoundZone=1 ;
6336	break ;
6337	}
6338
6339	}
6340	else
6341	nFoundZone=1 ;
6342
6343
6344	if(nFoundZone) // if the light touches this zone, or we're ignoring lights
6345	{
6346	// if the zone node is not already attached, attach it.
6347
6348	if( m_nOpaqueNodeUsed[nZone] && (nMaterialFlags&MAT_OPAQUE) && !m_pOpaqueNode[nZone]->isInSceneGraph() )
6349	m_pSceneMgr->getRootSceneNode()->addChild(m_pOpaqueNode[nZone]) ;
6350
6351	if( m_nTransNodeUsed[nZone] && (nMaterialFlags&MAT_GEL) && !m_pTransNode[nZone]->isInSceneGraph() )
6352	m_pSceneMgr->getRootSceneNode()->addChild(m_pTransNode[nZone]) ;
6353
6354	if( m_nLampNodeUsed[nZone] && (nMaterialFlags&MAT_LAMP) && !m_pLampNode[nZone]->isInSceneGraph() )
6355	m_pSceneMgr->getRootSceneNode()->addChild(m_pLampNode[nZone]) ;
6356
6357	if( m_nGlowNodeUsed[nZone] && (nMaterialFlags&MAT_GLOW) && !m_pGlowNode[nZone]->isInSceneGraph() )
6358	m_pSceneMgr->getRootSceneNode()->addChild(m_pGlowNode[nZone]) ;
6359	}
6360	}
6361
6362	}
6363
6364	bool OgreFramework::LightTouchesZone(int nLight, int nZone)
6365	{
6366	int nLightZone=0 ;
6367	int nMaxLightZone=0 ;
6368
6369	nMaxLightZone=m_Q3Map->m_nLightTouchesZone[nLight][INDEX_LIGHTZONECOUNT] ;
6370
6371	for(nLightZone=0 ; nLightZone<nMaxLightZone ; nLightZone++)
6372	if(m_Q3Map->m_nLightTouchesZone[nLight][nLightZone]==nZone)
6373	return true ;
6374
6375	return false ;
6376	}
6377
6378
6379	// last chance to cull some more multizone lights
6380	// Then we set all zones the remaining multizone lights touch to visible so that we get correct shadows
6381	void OgreFramework::CheckMultiZoneLights(int nCameraZone, char* pZoneVis, char* pLightVis, char* pSubLightVis)
6382	{
6383	int nLightMax=m_Q3Map->m_nMaxMultiZoneLight ;
6384	int nLight=0 ;
6385	int nLightIndex=0 ;
6386	// int nLightVal=0 ;
6387	int nOpenPortals=0 ;
6388	// int nZoneHasOpenPortals=0 ;
6389	int nPortal=0 ;
6390	int nPortalIndex=0 ;
6391	int nMaxPortal=0 ;
6392	// int nZone=0 ;
6393	// int nMaxZone=0 ;
6394	// int nZoneIndex=0 ;
6395
6396	int nSubLightMax=0 ;
6397	// int nSubLightIndex=0 ;
6398	int nSubLight=0 ;
6399	int nSubLightStart=0 ;
6400
6401	int nPortalLightMax=0 ;
6402	int nPortalLightIndex=0 ;
6403	// int nPortalLight=0 ;
6404
6405	int nCentreZone=0 ;
6406
6407
6408	for(nLightIndex=0 ; nLightIndex<nLightMax ; nLightIndex++)
6409	{
6410	nLight=m_Q3Map->m_nMultiZoneLight[nLightIndex] ;
6411	if(pLightVis[nLight]==LIGHT_VISIBLE) // try to kill multizone lights that are currently set as visible
6412	{
6413
6414	////////////////////////////////////////////////////////////////////////////////////////////////////////////.
6415	// if the zone that contains the centre isn't visible,
6416	// and the portals that the light touches are closed,
6417	// then this light can't be visible anywhere else
6418
6419	nCentreZone=m_Q3Map->m_pLight[nLight].CentreZone ;
6420
6421
6422	// is the zone that contains the light centre not visible?
6423	if(pZoneVis[nCentreZone]!=ZONE_VISIBLE)
6424	{
6425	// check the portals on the centre sublight zone.
6426	// If the ones that the light touches are closed,
6427	// then this light can't be visible
6428
6429
6430	nMaxPortal=m_Q3Map->m_nZoneTouchesPortal[nCentreZone][INDEX_PORTALCOUNT] ;
6431	nOpenPortals=0 ;
6432	nSubLightStart=m_Q3Map->m_pLight[nLight].SubLightStart ; // the first sublight also contains the light centre
6433
6434	for(nPortalIndex=0 ; nPortalIndex<nMaxPortal ; nPortalIndex++)
6435	{
6436	nPortal=m_Q3Map->m_nZoneTouchesPortal[nCentreZone][nPortalIndex] ;
6437
6438	// if portal's open...
6439	if(m_chPortalState[nPortal]&PORTALSTATE_OPEN)
6440	{
6441	nPortalLightMax=m_Q3Map->m_nPortalTouchesLight[nPortal][INDEX_PORTALLIGHTCOUNT] ;
6442
6443	// scan all the lights that touch this portal to see if our current light is one of them
6444	for(nPortalLightIndex=0 ; nPortalLightIndex<nPortalLightMax ; nPortalLightIndex++)
6445	if(m_Q3Map->m_nPortalTouchesLight[nPortal][nPortalLightIndex]==nLight)
6446	{
6447	nOpenPortals=1 ;
6448	break ;
6449	}
6450
6451	}// end if portal is open
6452
6453	if(nOpenPortals) break ; // get out if we found an open portal that the light touches
6454	}// end for portals
6455
6456
6457
6458	// if none of the portals touched by the centre light were open, set this light and it's sublights to not visible
6459	if(nOpenPortals==0)
6460	{
6461	pLightVis[nLight]=LIGHT_UNCHECKED ;
6462
6463	nSubLightStart=m_Q3Map->m_pLight[nLight].SubLightStart ; // the first sublight also contains the light centre
6464	nSubLightMax=nSubLightStart+m_Q3Map->m_pLight[nLight].ZoneCount ;
6465
6466	for(nSubLight=nSubLightStart ; nSubLight<nSubLightMax ; nSubLight++)
6467	pSubLightVis[nSubLightStart]=LIGHT_UNCHECKED ;
6468
6469	}// end if no light centre portals that touched lights were open
6470
6471
6472
6473	}// end if light centre zone isn't visible
6474
6475	}// end if light is visibile
6476
6477	}// end for lightindex
6478
6479	}
6480
6481
6482	// for lights that touch multiple zones, work out what additional zones we need to make
6483	// visible in order that lighting will come out with correct shadows.
6484	void OgreFramework::AddZonesFromMultiZoneLights(char* pZoneVis, char* pLightVis, char* pSubLightVis)
6485	{
6486	int nLightMax=m_Q3Map->m_nMaxMultiZoneLight ;
6487	int nLight=0 ;
6488	int nLightIndex=0 ;
6489	float flMinX=0.0f ;
6490	float flMaxX=0.0f ;
6491	float flMinY=0.0f ;
6492	float flMaxY=0.0f ;
6493	float flMinZ=0.0f ;
6494	float flMaxZ=0.0f ;
6495
6496	int nSubLightMax=0 ;
6497	// int nSubLightIndex=0 ;
6498	int nSubLight=0 ;
6499	int nSubLightStart=0 ;
6500	int nSubLightFirst=0 ;
6501
6502	int nInnerLight=0 ;
6503
6504
6505	for(nLightIndex=0 ; nLightIndex<nLightMax ; nLightIndex++)
6506	{
6507	nLight=m_Q3Map->m_nMultiZoneLight[nLightIndex] ;
6508	if(pLightVis[nLight]==LIGHT_VISIBLE)
6509	{
6510	nSubLightStart=m_Q3Map->m_pLight[nLight].SubLightStart ; // the first sublight also contains the light centre
6511	nSubLightFirst=nSubLightStart+1 ;// start from the first sublight after the one containing the centre
6512	nSubLightMax=nSubLightStart+m_Q3Map->m_pLight[nLight].ZoneCount ;
6513
6514
6515	for(nSubLight=nSubLightStart ; nSubLight<nSubLightMax ; nSubLight++)
6516	if(pSubLightVis[nSubLight]==LIGHT_VISIBLE) // sublight is visible (and unchecked)
6517	{
6518	// create the new AABB
6519	// this is bounded by this sublight and the centre holding sublight.
6520	flMinX = m_Q3Map->m_SubLight[nSubLight].Min[0] < m_Q3Map->m_SubLight[nSubLightStart].Min[0] ? m_Q3Map->m_SubLight[nSubLight].Min[0] : m_Q3Map->m_SubLight[nSubLightStart].Min[0] ;
6521	flMinY = m_Q3Map->m_SubLight[nSubLight].Min[1] < m_Q3Map->m_SubLight[nSubLightStart].Min[1] ? m_Q3Map->m_SubLight[nSubLight].Min[1] : m_Q3Map->m_SubLight[nSubLightStart].Min[1] ;
6522	flMinZ = m_Q3Map->m_SubLight[nSubLight].Min[2] < m_Q3Map->m_SubLight[nSubLightStart].Min[2] ? m_Q3Map->m_SubLight[nSubLight].Min[2] : m_Q3Map->m_SubLight[nSubLightStart].Min[2] ;
6523
6524	flMaxX = m_Q3Map->m_SubLight[nSubLight].Max[0] > m_Q3Map->m_SubLight[nSubLightStart].Max[0] ? m_Q3Map->m_SubLight[nSubLight].Max[0] : m_Q3Map->m_SubLight[nSubLightStart].Max[0] ;
6525	flMaxY = m_Q3Map->m_SubLight[nSubLight].Max[1] > m_Q3Map->m_SubLight[nSubLightStart].Max[1] ? m_Q3Map->m_SubLight[nSubLight].Max[1] : m_Q3Map->m_SubLight[nSubLightStart].Max[1] ;
6526	flMaxZ = m_Q3Map->m_SubLight[nSubLight].Max[2] > m_Q3Map->m_SubLight[nSubLightStart].Max[2] ? m_Q3Map->m_SubLight[nSubLight].Max[2] : m_Q3Map->m_SubLight[nSubLightStart].Max[2] ;
6527
6528	for(nInnerLight=nSubLightStart ; nInnerLight<nSubLightMax ; nInnerLight++)
6529	{
6530
6531
6532	if(
6533	(nInnerLight!=nSubLight) // no need to test itself
6534	&&(pZoneVis[ m_Q3Map->m_SubLight[nInnerLight].Zone ] != ZONE_VISIBLE) // don't test if already visible
6535	// if overlap, InnerLight's zone is visible
6536	&&(flMinX<m_Q3Map->m_SubLight[nInnerLight].Max[0]) && (flMaxX>m_Q3Map->m_SubLight[nInnerLight].Min[0])
6537	&&(flMinY<m_Q3Map->m_SubLight[nInnerLight].Max[1]) && (flMaxY>m_Q3Map->m_SubLight[nInnerLight].Min[1])
6538	&&(flMinZ<m_Q3Map->m_SubLight[nInnerLight].Max[2]) && (flMaxZ>m_Q3Map->m_SubLight[nInnerLight].Min[2])
6539	)
6540	{
6541	pZoneVis[ m_Q3Map->m_SubLight[nInnerLight].Zone ]=ZONE_VISIBLE ; // flag this zone as visible
6542	m_nTotalTriangles+=m_nZoneTriangleCount[ m_Q3Map->m_SubLight[nInnerLight].Zone ] ; // just some stats for interest
6543	}
6544
6545	} // end for innerlight
6546
6547	}// end if sublight is visible
6548
6549	}// end if light is visible
6550
6551	}// end for nLightIndex
6552
6553	}
6554
6555	// scan all the unchecked portals in a subzone to see if they are visible,
6556	// then move into any visible subzones and recurse.
6557	// scalex and scaley will convert the screen space numbers (-1 to 1) into frustum numbers (varies, often -0.5ish to 0.5ish) which is probably due to screen aspect ratios etc
6558
6559	// we also add visible lights if they are in the view frustum
6560	void OgreFramework::PortalScan(Ogre::Camera pCamera, int nZone, Ogre::Real ScaleX, Ogre::Real ScaleY, char pZoneVis, char* pLightVis, char* pSubLightVis, char* pPortalVis, int* pMaxVisibleLight, unsigned short* pVisibleLightList)
6561	{
6562	Ogre::Real OrigL, OrigR, OrigT, OrigB ; // original frustum extents
6563	Ogre::Real PortalL, PortalR, PortalT, PortalB ; // frustum extents per each portal in this zone
6564	pCamera->getFrustumExtents(OrigL, OrigR, OrigT, OrigB) ;
6565
6566
6567
6568
6569	Ogre::AxisAlignedBox AAB ;
6570
6571
6572	int nPortalMax=m_Q3Map->m_nZoneTouchesPortal[nZone][INDEX_PORTALCOUNT] ;
6573	int nPortalIndex=0 ;
6574	int nPortal=0 ;
6575
6576	int nPortalZoneMax=0 ;
6577	int nPortalZone=0 ;
6578	int nPortalZoneIndex=0 ;
6579
6580
6581	//////////////////////////////////////////////////////////////////////////////////////
6582	//
6583	// LIGHTING CHECKS
6584	//
6585
6586	int nLight=0;
6587	int nLightVal=0 ;
6588	// int nLightIndex=0 ;
6589	// int nMaxLight=0 ;
6590
6591	int nSubLight=0 ;
6592	int nSubLightIndex=0 ;
6593	int nMaxSubLight=0 ;
6594	// int nSubLightVal=0 ;
6595
6596
6597	// check all lights completely contained in this zone to see if they're visible
6598	nMaxSubLight=m_Q3Map->m_nZoneTouchesSubLight[nZone][INDEX_LIGHTCOUNT] ;
6599	for(nSubLightIndex=0 ; nSubLightIndex<nMaxSubLight ; nSubLightIndex++)
6600	{
6601	nSubLight=m_Q3Map->m_nZoneTouchesSubLight[nZone][nSubLightIndex] ;
6602	//nSubLightVal=m_chSubLightVis[nSubLight] ;
6603
6604	nLight=m_Q3Map->m_SubLight[nSubLight].Light ;
6605	nLightVal=pLightVis[nLight] ;
6606
6607	// if we haven't previously established that the light is visible or out of the frustum, check it.
6608
6609	AAB.setExtents(m_Q3Map->m_SubLight[nSubLight].Min[0], m_Q3Map->m_SubLight[nSubLight].Min[1], m_Q3Map->m_SubLight[nSubLight].Min[2], m_Q3Map->m_SubLight[nSubLight].Max[0], m_Q3Map->m_SubLight[nSubLight].Max[1], m_Q3Map->m_SubLight[nSubLight].Max[2]) ;
6610	if(pCamera->isVisible(AAB)) // sublight is visible
6611	{
6612	// flag this light and sublight as visible
6613	if((nLightVal!=LIGHT_VISIBLE) && (*pMaxVisibleLight<MAXVISIBLELIGHT))
6614	{
6615	pVisibleLightList[*pMaxVisibleLight]=nLight ;
6616	pMaxVisibleLight=pMaxVisibleLight+1 ;
6617	}
6618	pSubLightVis[nSubLight] = pLightVis[nLight] = LIGHT_VISIBLE ;
6619
6620	}
6621
6622
6623	}// end for lights in zone
6624
6625
6626	//
6627	///////////////////////////////////////////////////////////////////////////////////////
6628
6629
6630
6631
6632
6633	pZoneVis[nZone]=ZONE_VISIBLE ; // flag this zone as visible
6634	m_nTotalTriangles+=m_nZoneTriangleCount[nZone] ; // just some stats for interest
6635
6636
6637	// loop through all the portals in this zone
6638	for(nPortalIndex=0 ; nPortalIndex<nPortalMax ; nPortalIndex++)
6639	{
6640
6641
6642	nPortal=m_Q3Map->m_nZoneTouchesPortal[nZone][nPortalIndex] ;
6643
6644
6645	if((pPortalVis[nPortal]&PORTAL_VISCHECK)==0) // portal hasn't already been checked
6646	{
6647
6648	pPortalVis[nPortal] \|= PORTAL_VISCHECK ; // flag portal as vischecked
6649	AAB.setExtents(m_Q3Map->m_pPortals[nPortal].Min[0], m_Q3Map->m_pPortals[nPortal].Min[1], m_Q3Map->m_pPortals[nPortal].Min[2], m_Q3Map->m_pPortals[nPortal].Max[0], m_Q3Map->m_pPortals[nPortal].Max[1], m_Q3Map->m_pPortals[nPortal].Max[2]) ;
6650
6651	if(pCamera->isVisible(AAB)) // portal is in the view frustum
6652	{
6653
6654	pPortalVis[nPortal] \|= PORTAL_VISIBLE ; // flag portal as visible
6655
6656	// if the portal is open, go in and check the new zone.
6657	if(m_chPortalState[nPortal]&PORTALSTATE_OPEN)
6658	{
6659
6660	// calculate the new frustum extents through this portal
6661	PortalL=OrigL ;
6662	PortalR=OrigR ;
6663	PortalT=OrigT ;
6664	PortalB=OrigB ;
6665
6666	if(CalculatePortalFrustum(pCamera, nPortal, &PortalL, &PortalR, &PortalT, &PortalB, ScaleX, ScaleY))
6667	{
6668
6669
6670
6671
6672
6673	// Loop through all the zones attached to this portal
6674	nPortalZoneMax=m_Q3Map->m_nPortalTouchesZone[nPortal][INDEX_PORTALZONECOUNT] ;
6675	for(nPortalZoneIndex=0 ; nPortalZoneIndex<nPortalZoneMax ; nPortalZoneIndex++)
6676	{
6677	nPortalZone=m_Q3Map->m_nPortalTouchesZone[nPortal][nPortalZoneIndex] ;
6678	if(pZoneVis[nPortalZone]==ZONE_UNCHECKED) // don't go back into zones we've already scanned.
6679	{
6680
6681	pCamera->setFrustumExtents(PortalL, PortalR, PortalT, PortalB) ; // set the frustum extents
6682
6683	// recurse
6684	//m_nRecurseCount++ ;
6685	PortalScan(pCamera, nPortalZone, ScaleX, ScaleY, pZoneVis, pLightVis, pSubLightVis, pPortalVis, pMaxVisibleLight, pVisibleLightList) ;
6686	//m_nRecurseCount-- ;
6687
6688
6689
6690	}// end if zone hasn't already been checked
6691
6692	}// end scanning all zones connected by this portal
6693
6694	}// end if frustum is still active
6695
6696	}// end if portal is open
6697
6698	}// end if portal is in the view frustum
6699
6700	}// end if portal hasn't been checked
6701
6702	// reset the frustum
6703	pCamera->setFrustumExtents(OrigL, OrigR, OrigT, OrigB) ; // reset the original frustum extents
6704
6705	}// end for portalindex
6706
6707
6708	}
6709
6710	// gives new frustum settings, and returns 0 if the frustum has been killed completely.
6711	int OgreFramework::CalculatePortalFrustum(Ogre::Camera pCamera, int nPortal, Ogre::Real pPortalL, Ogre::Real* pPortalR, Ogre::Real* pPortalT, Ogre::Real* pPortalB, Ogre::Real ScaleX, Ogre::Real ScaleY)
6712	{
6713
6714
6715	// if the camera is actually inside the portal then don't change the frustum but return OK
6716	Vector3 CamPos=pCamera->getPosition() ;
6717
6718	if(
6719	(CamPos.x>=m_Q3Map->m_pPortals[nPortal].Min[0]) && (CamPos.x<=m_Q3Map->m_pPortals[nPortal].Max[0])
6720	&&(CamPos.y>=m_Q3Map->m_pPortals[nPortal].Min[1]) && (CamPos.y<=m_Q3Map->m_pPortals[nPortal].Max[1])
6721	&&(CamPos.z>=m_Q3Map->m_pPortals[nPortal].Min[2]) && (CamPos.z<=m_Q3Map->m_pPortals[nPortal].Max[2])
6722	)
6723	return 1 ;
6724
6725
6726
6727
6728
6729	int nLoop=0 ;
6730	int nBehindPoint=0 ; // keep track of how many transformed points are behind the camera
6731	//Real OrigL=*pPortalL ;
6732	//Real OrigR=*pPortalR ;
6733	//Real OrigT=*pPortalT ;
6734	//Real OrigB=*pPortalB ;
6735
6736	Real MinX=MINMAXLIMIT ;
6737	Real MaxX=-MINMAXLIMIT ;
6738	Real MaxY=-MINMAXLIMIT ;
6739	Real MinY=MINMAXLIMIT ;
6740
6741
6742	// set portal corners as 8 individual points. order is xyz, Xyz, xYz, XYz, xyZ, XyZ, xYZ, XYZ,
6743	Vector3 xyz[8] ;
6744
6745
6746	xyz[0].x=m_Q3Map->m_pPortals[nPortal].Min[0] ;
6747	xyz[0].y=m_Q3Map->m_pPortals[nPortal].Min[1] ;
6748	xyz[0].z=m_Q3Map->m_pPortals[nPortal].Min[2] ;
6749
6750	xyz[1].x=m_Q3Map->m_pPortals[nPortal].Max[0] ;
6751	xyz[1].y=m_Q3Map->m_pPortals[nPortal].Min[1] ;
6752	xyz[1].z=m_Q3Map->m_pPortals[nPortal].Min[2] ;
6753
6754	xyz[2].x=m_Q3Map->m_pPortals[nPortal].Min[0] ;
6755	xyz[2].y=m_Q3Map->m_pPortals[nPortal].Max[1] ;
6756	xyz[2].z=m_Q3Map->m_pPortals[nPortal].Min[2] ;
6757
6758	xyz[3].x=m_Q3Map->m_pPortals[nPortal].Max[0] ;
6759	xyz[3].y=m_Q3Map->m_pPortals[nPortal].Max[1] ;
6760	xyz[3].z=m_Q3Map->m_pPortals[nPortal].Min[2] ;
6761
6762	xyz[4].x=m_Q3Map->m_pPortals[nPortal].Min[0] ;
6763	xyz[4].y=m_Q3Map->m_pPortals[nPortal].Min[1] ;
6764	xyz[4].z=m_Q3Map->m_pPortals[nPortal].Max[2] ;
6765
6766	xyz[5].x=m_Q3Map->m_pPortals[nPortal].Max[0] ;
6767	xyz[5].y=m_Q3Map->m_pPortals[nPortal].Min[1] ;
6768	xyz[5].z=m_Q3Map->m_pPortals[nPortal].Max[2] ;
6769
6770	xyz[6].x=m_Q3Map->m_pPortals[nPortal].Min[0] ;
6771	xyz[6].y=m_Q3Map->m_pPortals[nPortal].Max[1] ;
6772	xyz[6].z=m_Q3Map->m_pPortals[nPortal].Max[2] ;
6773
6774	xyz[7].x=m_Q3Map->m_pPortals[nPortal].Max[0] ;
6775	xyz[7].y=m_Q3Map->m_pPortals[nPortal].Max[1] ;
6776	xyz[7].z=m_Q3Map->m_pPortals[nPortal].Max[2] ;
6777
6778	// transform the points to eyespace
6779	for(nLoop=0 ; nLoop<8 ; nLoop++)
6780	xyz[nLoop]=m_ViewMatrixxyz[nLoop] ;//pCamera->getViewMatrix(true)xyz[nLoop] ;
6781
6782	// transform the points to screen space
6783	for(nLoop=0 ; nLoop<8 ; nLoop++)
6784	if(xyz[nLoop].z<0) // less than zero means point is in front of camera
6785	{
6786	xyz[nLoop]=m_ProjectionMatrixxyz[nLoop] ;// pCamera->getProjectionMatrix()xyz[nLoop] ;
6787	if(xyz[nLoop].x<MinX) MinX=xyz[nLoop].x ;
6788	if(xyz[nLoop].x>MaxX) MaxX=xyz[nLoop].x ;
6789	if(xyz[nLoop].y<MinY) MinY=xyz[nLoop].y ;
6790	if(xyz[nLoop].y>MaxY) MaxY=xyz[nLoop].y ;
6791
6792	}
6793	else // point is behind the camera
6794	nBehindPoint++ ;
6795
6796
6797
6798
6799	MinX*=ScaleX ;
6800	MaxX*=ScaleX ;
6801	MinY*=ScaleY ;
6802	MaxY*=ScaleY ;
6803
6804	// apply the stereofrustum tweak if needed
6805	//float flTweak=0.0f ;
6806	//if(m_flStereoFrustumTweak!=0.0f)
6807	//{
6808	// MinX-=m_flStereoFrustumTweak ;
6809	// MaxX+=m_flStereoFrustumTweak ;
6810	//}
6811
6812
6813	// if we have more than three behindpoints, don't cull
6814	if(nBehindPoint>3) return 1 ;
6815
6816	// use these to cut down the frustum
6817	if(MinX>pPortalL) pPortalL=MinX ;
6818	if(MaxX<pPortalR) pPortalR=MaxX ;
6819	if(MinY>pPortalB) pPortalB=MinY ;
6820	if(MaxY<pPortalT) pPortalT=MaxY ;
6821
6822
6823
6824
6825
6826
6827
6828	// check if frustum has been cut out of existence
6829	// culling at this point didn't work, so this is a hack to make if function.
6830	if((pPortalL>=pPortalR) \|\| (pPortalB>=pPortalT))
6831	return 0 ;
6832
6833
6834	/*
6835	if(pPortalL>=pPortalR)
6836	{
6837	pPortalL=(pPortalL+*pPortalR)/2.0-0.01 ;
6838	pPortalR=pPortalL+0.02 ;
6839	}
6840
6841	if(pPortalB>=pPortalT)
6842	{
6843	pPortalB=(pPortalB+*pPortalT)/2.0-0.01 ;
6844	pPortalT=pPortalB+0.02 ;
6845	}
6846	*/
6847
6848
6849	//return 0 ;
6850
6851
6852	return 1 ;
6853	}
6854
6855
6856
6857
6858
6859
6860
6861
6862	/***********************************************************************************************************\
6863
6864	LIGHTING SETUP
6865
6866	\***********************************************************************************************************/
6867
6868
6869
6870
6871
6872	void OgreFramework::initLight()
6873	{
6874	// char chMessage[1024] ;
6875
6876	// these lights only have placeholder settings to begin with, since they get moved around and reused thoughout the level.
6877
6878	int nLt=0 ;
6879	int nMaxLt=MAXLIGHTPERLOOP ;
6880	Light *light;
6881	char chLightName[1024] ;
6882
6883
6884
6885
6886	for(nLt=0 ; nLt<nMaxLt ; nLt++)
6887	{
6888	sprintf(chLightName, "LT%02i", nLt) ;
6889
6890	light = m_pSceneMgr->createLight(chLightName);
6891	light->setType(Light::LT_SPOTLIGHT);
6892	light->setCastShadows(true);
6893	light->setVisible(false) ;
6894
6895	}
6896
6897	}
6898
6899	/***********************************************************************************************************\
6900
6901	CONFIG FILE
6902
6903	\***********************************************************************************************************/
6904
6905	void OgreFramework::ParseBZNConfig(void)
6906	{
6907	const int KVSIZE=1024 ;
6908	// make sure the config is a string
6909	int nConfigPos=-1 ;
6910	// int nPos=0 ;
6911	int nKeyPos=0 ;
6912	int nValuePos=0 ;
6913
6914	char chKey[KVSIZE] ;
6915	char chValue[KVSIZE] ;
6916	int nValue=0 ;
6917
6918
6919
6920	while(nConfigPos<BZN_CONFIG_SIZE)
6921	{
6922	// scan forward to find the next key
6923	while (
6924	(++nConfigPos<BZN_CONFIG_SIZE)
6925	&& ((m_chBZNConfig[nConfigPos]<'A') \|\| (m_chBZNConfig[nConfigPos]>'z'))
6926	) ;
6927
6928	if(nConfigPos<BZN_CONFIG_SIZE)
6929	{
6930
6931
6932
6933	// find the end of the key
6934	nKeyPos=0 ;
6935	while ((m_chBZNConfig[nConfigPos]!=' ') && (m_chBZNConfig[nConfigPos]!='/') && (m_chBZNConfig[nConfigPos]!=0x0A) && (m_chBZNConfig[nConfigPos]!=0x0D))
6936	{
6937	chKey[nKeyPos++]=m_chBZNConfig[nConfigPos++] ;
6938	if((nConfigPos==BZN_CONFIG_SIZE) \|\| (nKeyPos==KVSIZE))
6939	break ;
6940	}
6941
6942	if((nConfigPos<BZN_CONFIG_SIZE) && (nKeyPos<KVSIZE))
6943	{
6944	chKey[nKeyPos]='\0' ; // null terminate the key
6945
6946	// scan off the the number
6947	nValuePos=0 ;
6948
6949
6950	while ((m_chBZNConfig[nConfigPos]!=0x0A) && (m_chBZNConfig[nConfigPos]!=0x0D) && (m_chBZNConfig[nConfigPos]!='/'))
6951	{
6952	if(
6953	((m_chBZNConfig[nConfigPos]>='0') && (m_chBZNConfig[nConfigPos]<='9'))
6954	\|\| (m_chBZNConfig[nConfigPos]=='-')
6955	\|\| (m_chBZNConfig[nConfigPos]=='.')
6956	)
6957	chValue[nValuePos++]=m_chBZNConfig[nConfigPos] ;
6958
6959	nConfigPos++ ;
6960	if((nConfigPos==BZN_CONFIG_SIZE) \|\| (nKeyPos==KVSIZE))
6961	break ;
6962	}
6963
6964	if((nConfigPos<BZN_CONFIG_SIZE) && (nValuePos<KVSIZE))
6965	{
6966	chValue[nValuePos]='\0' ; // null terminate the value
6967
6968	// convert value string to a float
6969	nValue=atoi(chValue) ;
6970
6971	// assign that value
6972	if(strcmp("r_shadowmapsize", chKey)==0) { m_nShadowMapSize=nValue ; if(m_nShadowMapSize<2) m_nShadowMapSize=2 ; }
6973	if(strcmp("r_shadowrgbsize", chKey)==0) { m_nShadowRGBSize=nValue ; if(m_nShadowRGBSize<2) m_nShadowRGBSize=2 ; }
6974	if(strcmp("r_colouredshadow", chKey)==0) { m_nColouredShadow=nValue ; }
6975	if(strcmp("r_renderhdr", chKey)==0) { m_nRenderHDR=nValue ; }
6976	if(strcmp("r_maxgpuquery", chKey)==0) { m_nMaxGPUQuery=nValue ; if(m_nMaxGPUQuery<0) m_nMaxGPUQuery=0 ; if(m_nMaxGPUQuery>MAXGPUQUERY) m_nMaxGPUQuery=MAXGPUQUERY ; }
6977
6978	//sprintf(m_chBug, "Key: %s, Value: %i", chKey, nValue) ;
6979	//m_pLog->logMessage(m_chBug);
6980
6981	}// end found end of value
6982
6983
6984
6985
6986
6987
6988
6989	}// end found end of key
6990
6991
6992
6993
6994
6995	}// end found start of key
6996
6997
6998
6999	}// end scanning whole config
7000
7001
7002	}

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

Download in other formats: