Context Navigation

source: GTP/trunk/App/Demos/Illum/Ogre/src/DiffuseTest/include/DiffuseTest.h @ 1868

Revision 1868, 25.7 KB checked in by szirmay, 18 years ago (diff)

Line
1
2
3
4	/*
5	-----------------------------------------------------------------------------
6	This source file is part of OGRE
7	(Object-oriented Graphics Rendering Engine)
8	For the latest info, see http://www.ogre3d.org/
9
10	Copyright (c) 2000-2005 The OGRE Team
11	Also see acknowledgements in Readme.html
12
13	You may use this sample code for anything you like, it is not covered by the
14	LGPL like the rest of the engine.
15	-----------------------------------------------------------------------------
16	*/
17
18	/**
19	\file
20	Lighting.h
21	\brief
22	Shows lighting support in OGRE. Also demonstrates the use of billboards
23	and controllers for automatic time-relative behaviour.
24	*/
25
26	#include "ExampleApplication.h"
27	#include "OgreIlluminationManager.h"
28	#include "FrameCapture.h"
29
30	FrameCapture* capture;
31	int scene = 3;
32
33	// Listener class for frame updates
34	class RaytraceDemoListener : public ExampleFrameListener
35	{
36	protected:
37
38	SceneNode* objectNode;
39	unsigned long framecount;
40
41	public:
42	RaytraceDemoListener(RenderWindow* window, Camera* maincam, SceneNode* objectNode)
43	:ExampleFrameListener(window, maincam)
44
45	{
46	this->mMoveSpeed = 2.0;
47	framecount = 0;
48	this->objectNode = objectNode;
49	}
50
51	void moveCamera()
52	{/*
53	mCamera->yaw(mRotX);
54	mCamera->pitch(mRotY);
55	mCamera->moveRelative(mTranslateVector);*/
56
57	mCamera->getParentSceneNode()->yaw(mRotX, Node::TransformSpace::TS_WORLD);
58	mCamera->getParentSceneNode()->pitch(mRotY, Node::TransformSpace::TS_LOCAL);
59	mCamera->getParentSceneNode()->translate(mTranslateVector, Node::TransformSpace::TS_LOCAL);
60
61	}
62
63	bool processUnbufferedKeyInput(const FrameEvent& evt)
64	{
65	static float lastTime = 0.0;
66	float thisTime = (float) Root::getSingleton().getTimer()->getMilliseconds() / 1000.0f;
67	float elapsed = thisTime - lastTime;
68	float move = elapsed * 0.25;
69	float rotate = 80.0 * move;
70
71	if (mInputDevice->isKeyDown(KC_UP))
72	{
73	objectNode->translate(0,0,move);
74	}
75	if (mInputDevice->isKeyDown(KC_MULTIPLY))
76	{
77	//objectNode->scale(1.1,1.1,1.1);
78	objectNode->rotate(Vector3(0,0,1), Degree(rotate));
79	mTimeUntilNextToggle = 1;
80	}
81	if (mInputDevice->isKeyDown(KC_DIVIDE))
82	{
83	//objectNode->scale(1.0/1.1,1.0/1.1,1.0/1.1);
84	objectNode->rotate(Vector3(1,0,0), Degree(rotate));
85	mTimeUntilNextToggle = 1;
86	}
87	if (mInputDevice->isKeyDown(KC_ADD))
88	{
89	objectNode->rotate(Vector3(0,1,0), Degree(rotate));
90	}
91	if (mInputDevice->isKeyDown(KC_HOME))
92	{
93	objectNode->translate(0,move,0);
94	}
95	if (mInputDevice->isKeyDown(KC_END))
96	{
97	objectNode->translate(0,-move,0);
98	}
99	if (mInputDevice->isKeyDown(KC_DOWN))
100	{
101	objectNode->translate(0,0,-move);
102	}
103	if (mInputDevice->isKeyDown(KC_RIGHT))
104	{
105	objectNode->translate(move,0,0);
106	}
107	if (mInputDevice->isKeyDown(KC_LEFT))
108	{
109	objectNode->translate(-move,0,0);
110	}
111
112	if (mInputDevice->isKeyDown(KC_A))
113	{
114	// Move camera left
115	mTranslateVector.x = -mMoveScale;
116	}
117
118	if (mInputDevice->isKeyDown(KC_D))
119	{
120	// Move camera RIGHT
121	mTranslateVector.x = mMoveScale;
122	}
123
124	/* Move camera forward by keypress. */
125	if ( mInputDevice->isKeyDown(KC_W) )
126	{
127	mTranslateVector.z = -mMoveScale;
128	}
129
130	/* Move camera backward by keypress. */
131	if (mInputDevice->isKeyDown(KC_S) )
132	{
133	mTranslateVector.z = mMoveScale;
134	}
135
136	if (mInputDevice->isKeyDown(KC_PGUP))
137	{
138	// Move camera up
139	mTranslateVector.y = mMoveScale;
140	}
141
142	if (mInputDevice->isKeyDown(KC_PGDOWN))
143	{
144	// Move camera down
145	mTranslateVector.y = -mMoveScale;
146	}
147
148	if( mInputDevice->isKeyDown( KC_ESCAPE) )
149	{
150	return false;
151	}
152
153	// see if switching is on, and you want to toggle
154	if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
155	{
156	switchMouseMode();
157	mTimeUntilNextToggle = 1;
158	}
159
160	if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_K) && mTimeUntilNextToggle <= 0)
161	{
162	// must be going from immediate keyboard to buffered keyboard
163	switchKeyMode();
164	mTimeUntilNextToggle = 1;
165	}
166	if (mInputDevice->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0)
167	{
168	mStatsOn = !mStatsOn;
169	showDebugOverlay(mStatsOn);
170
171	mTimeUntilNextToggle = 1;
172	}
173	if (mInputDevice->isKeyDown(KC_T) && mTimeUntilNextToggle <= 0)
174	{
175	switch(mFiltering)
176	{
177	case TFO_BILINEAR:
178	mFiltering = TFO_TRILINEAR;
179	mAniso = 1;
180	break;
181	case TFO_TRILINEAR:
182	mFiltering = TFO_ANISOTROPIC;
183	mAniso = 8;
184	break;
185	case TFO_ANISOTROPIC:
186	mFiltering = TFO_BILINEAR;
187	mAniso = 1;
188	break;
189	default:
190	break;
191	}
192	MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
193	MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
194
195
196	showDebugOverlay(mStatsOn);
197
198	mTimeUntilNextToggle = 1;
199	}
200
201	if (mInputDevice->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
202	{
203	char tmp[20];
204	sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
205	mWindow->writeContentsToFile(tmp);
206	mTimeUntilNextToggle = 0.5;
207	mWindow->setDebugText(String("Wrote ") + tmp);
208	}
209
210	if (mInputDevice->isKeyDown(KC_R) && mTimeUntilNextToggle <=0)
211	{
212	mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
213	switch(mSceneDetailIndex) {
214	case 0 : mCamera->setPolygonMode(PM_SOLID) ; break ;
215	case 1 : mCamera->setPolygonMode(PM_WIREFRAME) ; break ;
216	case 2 : mCamera->setPolygonMode(PM_POINTS) ; break ;
217	}
218	mTimeUntilNextToggle = 0.5;
219	}
220
221	static bool displayCameraDetails = false;
222	if (mInputDevice->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
223	{
224	displayCameraDetails = !displayCameraDetails;
225	mTimeUntilNextToggle = 0.5;
226	if (!displayCameraDetails)
227	mWindow->setDebugText("");
228	}
229	if (displayCameraDetails)
230	{
231	// Print camera details
232	mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) + " " +
233	"O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
234	}
235	if (mInputDevice->isKeyDown(KC_N) && mTimeUntilNextToggle <= 0)
236	{
237	capture->playEvent();
238	mTimeUntilNextToggle = 1;
239	}
240	if (mInputDevice->isKeyDown(KC_B) && mTimeUntilNextToggle <= 0)
241	{
242	capture->recordEvent();
243	mTimeUntilNextToggle = 1;
244	}
245	if (mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
246	{
247	capture->setSaving();
248	capture->playEvent();
249	mTimeUntilNextToggle = 1;
250	}
251
252	lastTime = thisTime;
253	// Return true to continue rendering
254	return true;
255	}
256	bool frameStarted(const FrameEvent& evt)
257	{
258	static bool first = true;
259
260
261	// lightNode->setPosition( 100.0 * Vector3(cos(-(float)framecount/500.0),2.0,sin(-(float)framecount/500.0)));
262
263
264	bool result = ExampleFrameListener::frameStarted(evt);
265	framecount++;
266	return result;
267	}
268
269
270
271	};
272
273
274	class FloorRenderTargetListener : public RenderTargetListener
275	{
276	public:
277	Entity* scene;
278	FloorRenderTargetListener(Entity* scene)
279	{
280	this->scene = scene;
281	}
282	void preRenderTargetUpdate(const RenderTargetEvent& evt)
283	{
284	scene->getSubEntity(0)->setVisible(false);
285	scene->getSubEntity(17)->setVisible(false);
286	scene->getSubEntity(35)->setVisible(false);
287	scene->getSubEntity(52)->setVisible(false);
288	}
289	void postRenderTargetUpdate(const RenderTargetEvent& evt)
290	{
291	scene->getSubEntity(0)->setVisible(true);
292	scene->getSubEntity(17)->setVisible(true);
293	scene->getSubEntity(35)->setVisible(true);
294	scene->getSubEntity(52)->setVisible(true);
295	}
296
297	};
298
299	class CeilRenderTargetListener : public RenderTargetListener
300	{
301	public:
302	Entity* scene;
303	CeilRenderTargetListener(Entity* scene)
304	{
305	this->scene = scene;
306	}
307	void preRenderTargetUpdate(const RenderTargetEvent& evt)
308	{
309	scene->getSubEntity(1)->setVisible(false);
310	scene->getSubEntity(18)->setVisible(false);
311	scene->getSubEntity(36)->setVisible(false);
312	scene->getSubEntity(53)->setVisible(false);
313	}
314	void postRenderTargetUpdate(const RenderTargetEvent& evt)
315	{
316	scene->getSubEntity(1)->setVisible(true);
317	scene->getSubEntity(18)->setVisible(true);
318	scene->getSubEntity(36)->setVisible(true);
319	scene->getSubEntity(53)->setVisible(true);
320	}
321
322	};
323
324	class ReflectionCameraFrameListener : public FrameListener
325	{
326	public:
327	Camera* floorReflCam;
328	Camera* ceilReflCam;
329	Camera* mainCamera;
330	ReflectionCameraFrameListener(Camera* floorcam, Camera* ceilCam, Camera* mainCam)
331	{
332	floorReflCam = floorcam;
333	ceilReflCam = ceilCam;
334	mainCamera = mainCam;
335	}
336	bool frameStarted(const FrameEvent& evt)
337	{
338	floorReflCam->setOrientation(mainCamera->getOrientation());
339	floorReflCam->setPosition(mainCamera->getPosition());
340
341	// ceilReflCam->setOrientation(mainCamera->getOrientation());
342	// ceilReflCam->setPosition(mainCamera->getPosition());
343
344	return true;
345	}
346	};
347	/** Application class */
348	class RaytraceDemoApplication : public ExampleApplication
349	{
350
351	public:
352
353	protected:
354	SceneNode* objectNode;
355
356	void createPostproc()
357	{
358	/*CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
359	"GameTools/Glow");
360	CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
361	"GameTools/Glow", true);*/
362
363	CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
364	"GameTools/ToneMap");
365	CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
366	"GameTools/ToneMap", true);
367
368	}
369
370
371	void createScene(void)
372	{
373
374	createPostproc();
375
376	OgreIlluminationManager::getSingleton().setMainCamera(mCamera);
377	OgreIlluminationManager::getSingleton().setMainViewport(mWindow->getViewport(0));
378
379	OgreIlluminationManager::getSingleton().setMaxJoinRadius(420);
380
381	Root::getSingleton()._setCurrentSceneManager(mSceneMgr);
382
383	mCamera->setPosition(0,1,0);
384	mCamera->setFOVy(Radian(Degree(80)));
385	mCamera->setFarClipDistance(200);
386	mCamera->setNearClipDistance(0.1);
387
388	capture = new FrameCapture(mWindow);
389	switch (scene)
390	{
391	case 1:
392	createScene1();break;
393	case 2:
394	createScene2();break;
395	case 3:
396	createScene3();break;
397	}
398	OgreIlluminationManager::getSingleton().initTechniques();
399
400
401	}
402
403	void createScene1()
404	{
405
406	mSceneMgr->setAmbientLight(ColourValue(0.1, 0.0537, 0.0));
407	//mSceneMgr->setAmbientLight(ColourValue(0.0, 0.0, 0.0));
408
409
410	// Skybox
411	//mSceneMgr->setSkyBox(true, "Examples/MorningSkyBox");
412
413	SceneNode* rootNode = mSceneMgr->getRootSceneNode();
414
415	Entity* object = mSceneMgr->createEntity("object", "chinaman.mesh");
416	object->setMaterialName("GameTools/Diffuse/use");
417	//object->setMaterialName("GameTools/Diffuse2");
418	objectNode = rootNode->createChildSceneNode();
419	objectNode->attachObject(object);
420	// objectNode->scale(0.05,0.05,0.05);
421	objectNode->scale(3,3,3);
422	// objectNode->setPosition(0,4,0);
423	objectNode->_updateBounds();
424
425	Entity* room = mSceneMgr->createEntity("atlascube", "diffscene.mesh");
426	//room->setMaterialName("GameTools/Phong");
427	SceneNode* roomNode = rootNode->createChildSceneNode();
428	//roomNode->setScale(10,10,10);
429	roomNode->attachObject(room);
430	roomNode->_updateBounds();
431
432	Light* bluelight = mSceneMgr->createLight("BlueLight");
433	bluelight->setType(Light::LT_POINT);
434	bluelight->setDiffuseColour(ColourValue(0.152,0.824, 1.0));
435	//bluelight->setSpecularColour(ColourValue(0.152,0.824, 1.0));
436	bluelight->setPowerScale(5.726);
437	bluelight->setAttenuation(12, 0, 1, 0);
438	SceneNode* bluelightNode = rootNode->createChildSceneNode();
439	bluelightNode->setPosition(-5.948,9.619,0.980);
440	bluelightNode->attachObject(bluelight);
441
442	Light* walllight1 = mSceneMgr->createLight("WallLight1");
443	walllight1->setType(Light::LT_POINT);
444	walllight1->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
445	//walllight1->setSpecularColour(ColourValue(0.988,1.0, 0.808));
446	walllight1->setPowerScale(2.5);
447	walllight1->setAttenuation(12, 0, 1, 0);
448	SceneNode* walllight1Node = rootNode->createChildSceneNode();
449	walllight1Node->setPosition(-4.822,9.353,-5.194);
450	walllight1Node->attachObject(walllight1);
451
452	Light* walllight2 = mSceneMgr->createLight("WallLight2");
453	walllight2->setType(Light::LT_POINT);
454	walllight2->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
455	//walllight2->setSpecularColour(ColourValue(0.988,1.0, 0.808));
456	walllight2->setPowerScale(2.5);
457	walllight2->setAttenuation(12, 0, 1, 0);
458	SceneNode* walllight2Node = rootNode->createChildSceneNode();
459	walllight2Node->setPosition(-4.822,9.353,5.150);
460	walllight2Node->attachObject(walllight2);
461
462	Light* walllight3 = mSceneMgr->createLight("WallLight3");
463	walllight3->setType(Light::LT_POINT);
464	walllight3->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
465	//walllight3->setSpecularColour(ColourValue(0.988,1.0, 0.808));
466	walllight3->setPowerScale(2.5);
467	walllight3->setAttenuation(12, 0, 1, 0);
468	SceneNode* walllight3Node = rootNode->createChildSceneNode();
469	walllight3Node->setPosition(-11.08,10.07,-24.658);
470	walllight3Node->attachObject(walllight3);
471
472	Light* walllight4 = mSceneMgr->createLight("WallLight4");
473	walllight4->setType(Light::LT_POINT);
474	walllight4->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
475	//walllight4->setSpecularColour(ColourValue(0.988,1.0, 0.808));
476	walllight4->setPowerScale(2.5);
477	walllight4->setAttenuation(12, 0, 1, 0);
478	SceneNode* walllight4Node = rootNode->createChildSceneNode();
479	walllight4Node->setPosition(-11.08,10.07,-11.474);
480	walllight4Node->attachObject(walllight4);
481
482	Light* redlight1 = mSceneMgr->createLight("RedLight1");
483	redlight1->setType(Light::LT_POINT);
484	redlight1->setDiffuseColour(ColourValue(1.0,0.367, 0.016));
485	//redlight1->setSpecularColour(ColourValue(1.0,0.367, 0.016));
486	redlight1->setPowerScale(3.59);
487	redlight1->setAttenuation(2, 0, 1, 0);
488	SceneNode* redlight1Node = rootNode->createChildSceneNode();
489	redlight1Node->setPosition(24.958,7.743,-10.838);
490	redlight1Node->attachObject(redlight1);
491
492	Light* redlight2 = mSceneMgr->createLight("RedLight2");
493	redlight2->setType(Light::LT_POINT);
494	redlight2->setDiffuseColour(ColourValue(1.0,0.367, 0.016));
495	//redlight2->setSpecularColour(ColourValue(1.0,0.367, 0.016));
496	redlight2->setPowerScale(3.59);
497	redlight2->setAttenuation(2, 0, 1, 0);
498	SceneNode* redlight2Node = rootNode->createChildSceneNode();
499	redlight2Node->setPosition(18.689,7.743,-10.838);
500	redlight2Node->attachObject(redlight2);
501	}
502
503	Camera* mReflectCamFloor;
504	Camera* mReflectCamCeil;
505	ReflectionCameraFrameListener* reflListener;
506	void createScene2()
507	{
508	mCamera->setPosition(0,5,10);
509	MovablePlane *floorPlane = new MovablePlane("ReflectPlaneFloor");
510	floorPlane->d = 0;
511	floorPlane->normal = Vector3::UNIT_Y;
512
513	RenderTexture* rttTexFloor = mRoot->getRenderSystem()->createRenderTexture( "FloorReflection", 512, 512, TEX_TYPE_2D, PF_R8G8B8 );
514	{
515	mReflectCamFloor = mSceneMgr->createCamera("ReflectCamFloor");
516	mReflectCamFloor->setNearClipDistance(mCamera->getNearClipDistance());
517	mReflectCamFloor->setFarClipDistance(mCamera->getFarClipDistance());
518	/* mReflectCamFloor->setAspectRatio(
519	(Real)mWindow->getViewport(0)->getActualWidth() /
520	(Real)mWindow->getViewport(0)->getActualHeight());*/
521	mReflectCamFloor->setFOVy(mCamera->getFOVy());
522	mReflectCamFloor->setAspectRatio(mCamera->getAspectRatio());
523
524	Viewport *v = rttTexFloor->addViewport( mReflectCamFloor );
525	v->setClearEveryFrame( true );
526	v->setBackgroundColour( ColourValue::Black );
527
528
529	// set up linked reflection
530	mReflectCamFloor->enableReflection(floorPlane);
531	// Also clip
532	mReflectCamFloor->enableCustomNearClipPlane(floorPlane);
533	}
534	/* MovablePlane *ceilPlane = new MovablePlane("ReflectPlaneCeil");
535	ceilPlane->d = -8;
536	ceilPlane->normal = Vector3::NEGATIVE_UNIT_Y;
537	RenderTexture* rttTexCeil = mRoot->getRenderSystem()->createRenderTexture( "CeilReflection", 512, 512, TEX_TYPE_2D, PF_R8G8B8 );
538	{
539	mReflectCamCeil = mSceneMgr->createCamera("ReflectCamCeil");
540	mReflectCamCeil->setNearClipDistance(mCamera->getNearClipDistance());
541	mReflectCamCeil->setFarClipDistance(mCamera->getFarClipDistance());
542	mReflectCamCeil->setAspectRatio(
543	(Real)mWindow->getViewport(0)->getActualWidth() /
544	(Real)mWindow->getViewport(0)->getActualHeight());
545
546	Viewport *v = rttTexCeil->addViewport( mReflectCamCeil );
547	v->setClearEveryFrame( true );
548	v->setBackgroundColour( ColourValue::Black );
549
550
551	// set up linked reflection
552	mReflectCamCeil->enableReflection(floorPlane);
553	// Also clip
554	mReflectCamCeil->enableCustomNearClipPlane(floorPlane);
555	}
556	*/
557	reflListener = new ReflectionCameraFrameListener(mReflectCamFloor, mReflectCamCeil, mCamera);
558	reflListener->setPriority(2);
559
560	// mSceneMgr->setAmbientLight(ColourValue(0.1, 0.0537, 0.0));
561	mSceneMgr->setAmbientLight(ColourValue(0.2, 0.25, 0.3));
562
563	SceneNode* rootNode = mSceneMgr->getRootSceneNode();
564
565	Entity* object = mSceneMgr->createEntity("object", "buddha.mesh");
566	object->setMaterialName("GameTools/Diffuse/use");
567	//object->setMaterialName("GameTools/Diffuse2");
568	objectNode = rootNode->createChildSceneNode();
569	objectNode->attachObject(object);
570	objectNode->scale(1.8,1.8,1.8);
571	objectNode->rotate(Vector3(0,1,0),Radian(Math::PI));
572	objectNode->setPosition(0,0,0);
573	objectNode->_updateBounds();
574
575	Entity* room = mSceneMgr->createEntity("scene", "uvegfolyoso2.mesh");
576	//room->setMaterialName("GameTools/Phong");
577	SceneNode* roomNode = rootNode->createChildSceneNode();
578	roomNode->attachObject(room);
579	roomNode->_updateBounds();
580	rttTexFloor->addListener(new FloorRenderTargetListener(room));
581	//rttTexCeil->addListener(new CeilRenderTargetListener(room));
582
583	Light* light1 = mSceneMgr->createLight("Light1");
584	light1->setType(Light::LT_POINT);
585	light1->setDiffuseColour(ColourValue(0.526,0.535, 0.974));
586	light1->setPowerScale(3);
587	SceneNode* lightNode1 = rootNode->createChildSceneNode();
588	lightNode1->setPosition(-1.266,4.131,-4.438);
589	lightNode1->attachObject(light1);
590
591	Light* light2 = mSceneMgr->createLight("Light2");
592	light2->setType(Light::LT_POINT);
593	light2->setDiffuseColour(ColourValue(0.391,0.781, 0.974));
594	light2->setPowerScale(3);
595	SceneNode* lightNode2 = rootNode->createChildSceneNode();
596	lightNode2->setPosition(-33.537,4.131,-4.438);
597	lightNode2->attachObject(light2);
598
599	Light* light3 = mSceneMgr->createLight("Light3");
600	light3->setType(Light::LT_POINT);
601	light3->setDiffuseColour(ColourValue(0.391,0.781, 0.974));
602	light3->setPowerScale(3);
603	SceneNode* lightNode3 = rootNode->createChildSceneNode();
604	lightNode3->setPosition(-97.446,4.131,-4.438);
605	lightNode3->attachObject(light3);
606
607	Light* light4 = mSceneMgr->createLight("Light4");
608	light4->setType(Light::LT_POINT);
609	light4->setDiffuseColour(ColourValue(0.304,0.974, 0.770));
610	light4->setPowerScale(3);
611	SceneNode* lightNode4 = rootNode->createChildSceneNode();
612	lightNode4->setPosition(-63.277,4.131,-4.438);
613	lightNode4->attachObject(light4);
614
615
616
617
618
619	}
620
621	void createScene3()
622	{
623	OgreIlluminationManager::getSingleton().setFocusingSM(false);
624	OgreIlluminationManager::getSingleton().setShadowMapSize(512);
625	OgreIlluminationManager::getSingleton().setBlurShadowMap(true);
626	OgreIlluminationManager::getSingleton().setShadowMapMaterialName("GameTools/ShadowMapDistance");
627	mSceneMgr->setAmbientLight(ColourValue(0.505 * 0.2, 0.897 * 0.2, 0.914 * 0.2));
628
629	SceneNode* rootNode = mSceneMgr->getRootSceneNode();
630
631	Entity* object = mSceneMgr->createEntity("object", "buddha.mesh");
632	object->setMaterialName("GameTools/Diffuse/use");
633	//object->setMaterialName("GameTools/DiffuseP2P");
634	objectNode = rootNode->createChildSceneNode();
635	objectNode->attachObject(object);
636	objectNode->scale(0.4,0.4,0.4);
637	objectNode->rotate(Vector3(0,1,0),Radian(Math::PI));
638	objectNode->setPosition(0,0,0);
639	objectNode->_updateBounds();
640
641	Entity* room = mSceneMgr->createEntity("scene", "difflab.mesh");
642	//room->setMaterialName("GameTools/Phong");
643	SceneNode* roomNode = rootNode->createChildSceneNode();
644	roomNode->attachObject(room);
645	roomNode->_updateBounds();
646
647	mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
648	Light* redLight1 = mSceneMgr->createLight("RedLight1");
649	redLight1->setType(Light::LT_POINT);
650	redLight1->setCastShadows(false);
651	redLight1->setDiffuseColour(ColourValue(1,0.055, 0.0));
652	redLight1->setPowerScale(1.6);
653	SceneNode* redLightNode1 = rootNode->createChildSceneNode();
654	redLightNode1->setPosition(0.05,2.361,-1.07);
655	redLightNode1->attachObject(redLight1);
656
657	Light* greenLight1 = mSceneMgr->createLight("GreenLight1");
658	greenLight1->setType(Light::LT_POINT);
659	greenLight1->setCastShadows(false);
660	greenLight1->setDiffuseColour(ColourValue(0.362,0.783, 0.685));
661	greenLight1->setPowerScale(2.0);
662	SceneNode* greenLightNode1 = rootNode->createChildSceneNode();
663	greenLightNode1->setPosition(1.312,1.313,0);
664	greenLightNode1->attachObject(greenLight1);
665
666	Light* mainBlueLight = mSceneMgr->createLight("MainBlueLight");
667	mainBlueLight->setType(Light::LT_SPOTLIGHT);
668	mainBlueLight->setCastShadows(true);
669	mainBlueLight->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
670	mainBlueLight->setPowerScale(5.0);
671	mainBlueLight->setSpotlightRange(Degree(0),Degree(160));
672	mainBlueLight->setAttenuation(2.5, 0, 1, 0);
673	SceneNode* mainBlueLightNode = rootNode->createChildSceneNode();
674	mainBlueLightNode->setPosition(-0.546,2.095,1.035);
675	//mainBlueLightNode->rotate(Vector3::UNIT_X, Degree(161.396));
676	//mainBlueLightNode->rotate(Vector3::UNIT_Y, Degree(53.955));
677	//mainBlueLightNode->rotate(Vector3::UNIT_Z, Degree(-145.065));
678	mainBlueLight->setDirection(-1.5,-2.0,1.0);
679	mainBlueLightNode->attachObject(mainBlueLight);
680	/*
681	Light* blueLight1 = mSceneMgr->createLight("BlueLight1");
682	blueLight1->setType(Light::LT_SPOTLIGHT);
683	blueLight1->setCastShadows(false);
684	blueLight1->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
685	blueLight1->setPowerScale(0.7);
686	blueLight1->setSpotlightRange(Degree(20),Degree(90));
687	SceneNode* blueLightNode = rootNode->createChildSceneNode();
688	blueLightNode->setPosition(-0.9,2.095,0.185);
689	//blueLightNode->rotate(Vector3::UNIT_X, Degree(148.785));
690	//blueLightNode->rotate(Vector3::UNIT_Y, Degree(39.001));
691	//blueLightNode->rotate(Vector3::UNIT_Z, Degree(-154.304));
692	blueLight1->setDirection(-1.5,-2.0,1.0);
693	blueLightNode->attachObject(blueLight1);
694
695	Light* blueLight2 = mSceneMgr->createLight("BlueLight2");
696	blueLight2->setType(Light::LT_SPOTLIGHT);
697	blueLight2->setCastShadows(false);
698	blueLight2->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
699	blueLight2->setPowerScale(0.7);
700	blueLight2->setSpotlightRange(Degree(20),Degree(90));
701	SceneNode* blueLightNode2 = rootNode->createChildSceneNode();
702	blueLightNode2->setPosition(0.091,2.095,1.556);
703	//blueLightNode2->rotate(Vector3::UNIT_X, Degree(-112.941));
704	//blueLightNode2->rotate(Vector3::UNIT_Y, Degree(68.432));
705	//blueLightNode2->rotate(Vector3::UNIT_Z, Degree(-66.441));
706	blueLight2->setDirection(-1.5,-2.0,1.0);
707	blueLightNode2->attachObject(blueLight2); */
708	}
709
710	void createPlane(Ogre::String _name, Ogre::String _material, Ogre::Vector3 _pos, Ogre::Vector2 _size, Ogre::Vector2 _subdivisions = Ogre::Vector2(1,1)) {
711
712	Plane _plane;
713	_plane.normal = Vector3::UNIT_Y;
714	_plane.d = 0;
715
716
717	MeshManager::getSingleton().createPlane(_name + ".plane",
718	ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
719	_plane,_size.x,_size.y,1,1,true,1,_subdivisions.x,_subdivisions.y,Vector3::UNIT_Z);
720
721	Entity *_entity = mSceneMgr->createEntity(_name + ".entity", _name + ".plane");
722	_entity->setMaterialName(_material);
723
724	SceneNode* _node = mSceneMgr->getRootSceneNode()->createChildSceneNode(_name + ".node");
725	_node->attachObject(_entity);
726	_node->setPosition(_pos);
727	}
728
729
730
731	void createFrameListener(void)
732	{
733	// This is where we instantiate our own frame listener
734	mFrameListener= new RaytraceDemoListener(mWindow,
735	mCamera,
736	objectNode
737	);
738	mFrameListener->setPriority(1);
739	OgreIlluminationManager::getSingleton().setPriority(10);
740	capture->setPriority(6);
741	mRoot->addFrameListener(capture);
742	mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());
743	mRoot->addFrameListener(mFrameListener);
744	if(scene == 2)
745	mRoot->addFrameListener(reflListener);
746
747	}
748
749	};
750
751

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

Download in other formats: