source: GTP/trunk/App/Demos/Illum/Ogre/src/ReflectionTest/include/ReflectionTest.h @ 2274

Revision 2274, 22.6 KB checked in by szirmay, 17 years ago (diff)
Line 
1
2
3
4/*
5-----------------------------------------------------------------------------
6This source file is part of OGRE
7    (Object-oriented Graphics Rendering Engine)
8For the latest info, see http://www.ogre3d.org/
9
10Copyright (c) 2000-2005 The OGRE Team
11Also see acknowledgements in Readme.html
12
13You may use this sample code for anything you like, it is not covered by the
14LGPL 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
27#include "ExampleApplication.h"
28#include "OgreIlluminationManager.h"
29#include "SpriteParticleRenderer.h"
30#include "FrameCapture.h"
31#include "OgreCausticCubeMapRenderingRun.h"
32
33float worldSizeVar = 0.002;
34float refIndex = 0.995;
35int scene = 1;
36FrameCapture* capture;
37
38bool multiplebounce = true;
39bool useCauInt = true;
40
41int currentMaterial = 0;
42int currentObject = 1;
43String objectNames[] = {String("sphere.mesh"),
44                        String("teapot.mesh"),
45                                                String("colorcube.mesh"),
46                                                String("head.mesh")};
47
48float objectscales[] = {0.015,1.7,1,0.1};
49float scenescales[] = {0.3,1, 2.7};
50
51String materialNames[] = {String("GTP/MultiBounce/Reflector"),
52                                                        String("GTP/MultiBounce/Refractor"),
53                                                        String("GTP/MultiBounce/CausticRefractor"),
54                                                        String("GTP/MultiBounce/Reflector_MinMax"),
55                                                        String("GTP/MultiBounce/Refractor_MinMax"),
56                                                        String("GTP/MultiBounce/CausticRefractor_MinMax"),
57                                                        String("semmi")
58                                                        };
59                       
60String resourceGroupName[] = {  String("GTP_MultipleReflection"),
61                                                                String("GTP_MultipleRefraction"),
62                                                                String("GTP_MultipleRefraction"),
63                                                                String("GTP_MultipleReflection_MinMax"),
64                                                                String("GTP_MultipleRefraction_MinMax"),
65                                                                String("GTP_MultipleRefraction_MinMax"),
66                                                                String("GTP_Basic")};
67
68// Listener class for frame updates
69class RaytraceDemoListener : public ExampleFrameListener
70{
71protected:
72        unsigned long framecount;
73        SceneNode* objectNode;
74        Entity *object;
75       
76public:
77        void setMoveSpeed(float speed){mMoveSpeed = speed;}
78    RaytraceDemoListener(RenderWindow* window, Camera* maincam, SceneNode* objectNode, Entity* object)
79        :ExampleFrameListener(window, maincam)
80                                 
81    {
82                this->object = object;
83                this->mMoveSpeed = 1;
84                if(scene == 2)
85                this->mMoveSpeed = 1.0;
86                if(scene == 3)
87                this->mMoveSpeed = 10.0;
88                 mStatsOn = false;
89                 showDebugOverlay(mStatsOn);
90
91                framecount = 0;         
92                this->objectNode = objectNode;         
93               
94    }
95
96        void moveCamera()
97    {/*
98           mCamera->yaw(mRotX);
99       mCamera->pitch(mRotY);
100       mCamera->moveRelative(mTranslateVector);*/
101
102                mCamera->getParentSceneNode()->yaw(mRotX, Node::TransformSpace::TS_WORLD);
103                mCamera->getParentSceneNode()->pitch(mRotY, Node::TransformSpace::TS_LOCAL);
104                mCamera->getParentSceneNode()->translate(mTranslateVector, Node::TransformSpace::TS_LOCAL);
105               
106    }
107
108        bool processUnbufferedKeyInput(const FrameEvent& evt)
109    {
110                if (mInputDevice->isKeyDown(KC_F2) && mTimeUntilNextToggle <= 0)
111        {
112                        TexturePtr tex = TextureManager::getSingleton().getByName("SCREENSHOT");
113                        tex->getBuffer()->getRenderTarget()->update();
114                        tex->getBuffer()->getRenderTarget()->writeContentsToFile(String("screen") + StringConverter::toString(framecount) + ".tga");
115            mTimeUntilNextToggle = 0.5;           
116        }
117
118                static float lastTime = 0.0;
119                float thisTime = (float) Root::getSingleton().getTimer()->getMilliseconds() / 1000.0f;
120                float elapsed = thisTime - lastTime;
121                float move = elapsed * 0.5;
122                if(scene == 3 )
123                        move *= 10;
124                float rotate = 80.0 * move;
125                if (mInputDevice->isKeyDown(KC_G))
126        {
127                        worldSizeVar -= 0.002;
128                        if(worldSizeVar < 0.002)worldSizeVar = 0.002;
129                        MaterialPtr mat = MaterialManager::getSingleton().getByName("GTP/MultiBounce/CauCube_Trianglesobject_SE_0_clone");
130                        if(!mat.isNull())
131                        {
132                                GpuProgramParameters* Vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters().getPointer();
133                          Vparams->setNamedConstant("WorldSize", worldSizeVar);
134                        }
135                }
136                if (mInputDevice->isKeyDown(KC_H))
137        {
138                        worldSizeVar += 0.002;
139                        MaterialPtr mat = MaterialManager::getSingleton().getByName("GTP/MultiBounce/CauCube_Trianglesobject_SE_0_clone");
140                        if(!mat.isNull())
141                        {
142                                GpuProgramParameters* Vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters().getPointer();
143                          Vparams->setNamedConstant("WorldSize", worldSizeVar);
144                        }
145                }
146                if (mInputDevice->isKeyDown(KC_I) && mTimeUntilNextToggle <= 0)
147        {                       
148                        useCauInt = !useCauInt;
149
150                        MaterialPtr mat = MaterialManager::getSingleton().getByName("GTP/MultiBounce/CauCube_Trianglesobject_SE_0_clone");
151                        if(!mat.isNull())
152                        {
153                          GpuProgramParameters* Vparams = mat->getTechnique(0)->getPass(0)->getVertexProgramParameters().getPointer();
154                          Vparams->setNamedConstant("notUseIntensity", !useCauInt);
155                          if(useCauInt)
156                          {
157                                  mat->getTechnique(0)->getPass(0)->setPolygonMode(PM_SOLID);
158                                  OgreTechniqueGroup* tg = (OgreTechniqueGroup*) object->getSubEntity(0)->getRenderTechniqueGroup();
159                                  OgreCausticCubeMapRenderingRun* rr = (OgreCausticCubeMapRenderingRun*)
160                                                                tg->getSharedRuns()->getRun(ILLUMRUN_CAUSTIC_CUBEMAP)
161                                                                ->asOgreRenderingRun();
162                                  rr->setBlurMap(true);
163                          }
164                          else
165                          {
166                                   mat->getTechnique(0)->getPass(0)->setPolygonMode(PM_POINTS);
167                                   OgreTechniqueGroup* tg = (OgreTechniqueGroup*) object->getSubEntity(0)->getRenderTechniqueGroup();
168                                  OgreCausticCubeMapRenderingRun* rr = (OgreCausticCubeMapRenderingRun*)
169                                                                tg->getSharedRuns()->getRun(ILLUMRUN_CAUSTIC_CUBEMAP)
170                                                                ->asOgreRenderingRun();
171                                  rr->setBlurMap(false);
172                          }
173                        }
174                        mTimeUntilNextToggle = 1;
175        }
176                if (mInputDevice->isKeyDown(KC_J))
177        {                       
178                        refIndex -= 0.001;
179
180                        MaterialPtr mat1 = MaterialManager::getSingleton().getByName(materialNames[currentMaterial]);
181                        if(!mat1.isNull())
182                        {
183                          GpuProgramParameters* Fparams1 = mat1->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
184                          Fparams1->setNamedConstant("refIndex", refIndex);
185                        }
186                        //MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/MultiBounce/PhotonMap");
187                        MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/Caustic/PhotonMap_HitEnv");
188                        if(!mat2.isNull())
189                        {
190                          GpuProgramParameters* Fparams2 = mat2->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
191                          Fparams2->setNamedConstant("refIndex", refIndex);
192                        }
193        }
194                if (mInputDevice->isKeyDown(KC_K))
195        {
196                        refIndex += 0.001;
197                       
198                        MaterialPtr mat1 = MaterialManager::getSingleton().getByName(materialNames[currentMaterial]);
199                        if(!mat1.isNull())
200                        {
201                          GpuProgramParameters* Fparams1 = mat1->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
202                          Fparams1->setNamedConstant("refIndex", refIndex);
203                        }
204                        //MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/MultiBounce/PhotonMap");
205                        MaterialPtr mat2 = MaterialManager::getSingleton().getByName("GTP/Caustic/PhotonMap_HitEnv");
206                        if(!mat2.isNull())
207                        {
208                          GpuProgramParameters* Fparams2 = mat2->getTechnique(0)->getPass(0)->getFragmentProgramParameters().getPointer();
209                          Fparams2->setNamedConstant("refIndex", refIndex);
210                        }
211        }
212
213                if (mInputDevice->isKeyDown(KC_UP))
214        {
215                        objectNode->translate(0,0,move);
216        }
217                if (mInputDevice->isKeyDown(KC_MULTIPLY))
218        {
219                        //objectNode->scale(1.1,1.1,1.1);
220                        objectNode->rotate(Vector3(0,0,1), Degree(rotate));
221                       
222        }
223                if (mInputDevice->isKeyDown(KC_DIVIDE))
224        {
225                        //objectNode->scale(1.0/1.1,1.0/1.1,1.0/1.1);
226                        objectNode->rotate(Vector3(1,0,0), Degree(rotate));
227                       
228        }
229                if (mInputDevice->isKeyDown(KC_ADD))
230        {
231                        objectNode->rotate(Vector3(0,1,0), Degree(rotate));
232        }
233                if (mInputDevice->isKeyDown(KC_HOME))
234        {
235                        objectNode->translate(0,move,0);
236        }
237                if (mInputDevice->isKeyDown(KC_END))
238        {
239                        objectNode->translate(0,-move,0);
240        }
241                if (mInputDevice->isKeyDown(KC_DOWN))
242        {
243                        objectNode->translate(0,0,-move);
244        }
245                if (mInputDevice->isKeyDown(KC_RIGHT))
246        {
247                        objectNode->translate(-move,0,0);
248        }
249                if (mInputDevice->isKeyDown(KC_LEFT))
250        {
251                        objectNode->translate(move,0,0);
252        }
253
254                if (mInputDevice->isKeyDown(KC_A))
255        {
256            // Move camera left
257            mTranslateVector.x = -mMoveScale;
258        }
259
260        if (mInputDevice->isKeyDown(KC_D))
261        {
262            // Move camera RIGHT
263            mTranslateVector.x = mMoveScale;
264        }
265
266        /* Move camera forward by keypress. */
267        if ( mInputDevice->isKeyDown(KC_W) )
268        {
269            mTranslateVector.z = -mMoveScale;
270        }
271               
272        /* Move camera backward by keypress. */
273        if (mInputDevice->isKeyDown(KC_S) )
274        {
275            mTranslateVector.z = mMoveScale;
276        }
277
278        if (mInputDevice->isKeyDown(KC_PGUP))
279        {
280            // Move camera up
281            mTranslateVector.y = mMoveScale;
282        }
283
284        if (mInputDevice->isKeyDown(KC_PGDOWN))
285        {
286            // Move camera down
287            mTranslateVector.y = -mMoveScale;
288        }
289                if (mInputDevice->isKeyDown(KC_N) && mTimeUntilNextToggle <= 0)
290        {
291                        capture->playEvent();
292            mTimeUntilNextToggle = 1;
293        }
294                if (mInputDevice->isKeyDown(KC_B) && mTimeUntilNextToggle <= 0)
295        {
296                        capture->recordEvent();
297            mTimeUntilNextToggle = 1;
298        }
299                if (mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
300        {
301                        capture->setSaving();
302                        capture->playEvent();
303            mTimeUntilNextToggle = 1;
304        }       
305
306        if( mInputDevice->isKeyDown( KC_ESCAPE) )
307        {           
308            return false;
309        }
310
311                // see if switching is on, and you want to toggle
312        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
313        {
314                        switchMouseMode();
315            mTimeUntilNextToggle = 1;
316        }
317
318        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_K) && mTimeUntilNextToggle <= 0)
319        {
320                        // must be going from immediate keyboard to buffered keyboard
321                        switchKeyMode();
322            mTimeUntilNextToggle = 1;
323        }
324        if (mInputDevice->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0)
325        {
326            mStatsOn = !mStatsOn;
327            showDebugOverlay(mStatsOn);
328
329            mTimeUntilNextToggle = 1;
330        }
331       
332        if (mInputDevice->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
333        {
334                        char tmp[20];
335                        sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
336            mWindow->writeContentsToFile(tmp);
337            mTimeUntilNextToggle = 0.5;
338                        mWindow->setDebugText(String("Wrote ") + tmp);
339        }
340               
341                static bool displayCameraDetails = false;
342        if (mInputDevice->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
343        {
344            displayCameraDetails = !displayCameraDetails;
345            mTimeUntilNextToggle = 0.5;
346            if (!displayCameraDetails)
347                mWindow->setDebugText("");
348        }
349        if (displayCameraDetails)
350        {
351            // Print camera details
352            mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) + " " +
353                "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
354        }
355        lastTime = thisTime;
356        // Return true to continue rendering
357        return true;
358        }
359    bool frameStarted(const FrameEvent& evt)
360    {
361                bool result = ExampleFrameListener::frameStarted(evt);
362                framecount++;
363                return result;     
364    }
365};
366
367/** Application class */
368class RaytraceDemoApplication : public ExampleApplication
369{
370
371public:
372
373
374protected:
375
376        SceneNode* objectNode;
377        Texture* screenTexture;
378
379    void createCamera(void)
380    {
381        // Create the camera
382        mCamera = mSceneMgr->createCamera("PlayerCam");
383               
384                SceneNode* camNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("mainCameraNode");
385                camNode->attachObject(mCamera);
386       //camNode->setPosition(Vector3(0,1,0));
387        // Position it at 500 in Z direction
388        //mCamera->setPosition(Vector3(0,0,500));
389        // Look back along -Z
390        //mCamera->lookAt(Vector3(0,0,-300));
391        mCamera->setNearClipDistance(5);
392
393    }
394   
395        void loadResources(void)
396        {
397                // Initialise, parse scripts etc
398                ResourceGroupManager::getSingleton().initialiseResourceGroup("Bootstrap");
399                ResourceGroupManager::getSingleton().initialiseResourceGroup("General");
400                ResourceGroupManager::getSingleton().initialiseResourceGroup("PostProc");
401                ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Basic");
402                ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_EnvMap");
403                ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Caustic");
404                ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_MultiBounce_Shared");
405                ResourceGroupManager::getSingleton().initialiseResourceGroup(resourceGroupName[currentMaterial]);
406                if(currentMaterial == 2)
407                        ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_MultipleCausticRefraction");
408                if(currentMaterial == 5)
409                        ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_MultipleCausticRefraction_MinMax");
410        }
411        Entity* object;
412
413        void chooseSceneManager()
414        {
415                mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
416                //mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
417        }
418
419    void createPostproc()
420        {               
421                CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
422                                                                                                                "GTP/PostProc/Glow");
423                CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
424                                                                                                                "GTP/PostProc/Glow", true);
425/*
426                CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
427                                                                                                                "GTP/PostProc/ToneMap");
428                CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
429                                                                                                                "GTP/PostProc/ToneMap", true);  */     
430        }
431
432        void createScene(void)
433    {
434                //createPostproc();
435
436                OgreIlluminationManager::getSingleton().setMainCamera(mCamera);
437                OgreIlluminationManager::getSingleton().setMainViewport(mWindow->getViewport(0));
438               
439                OgreIlluminationManager::getSingleton().setMaxJoinRadius(420);         
440
441                Root::getSingleton()._setCurrentSceneManager(mSceneMgr);
442
443                mCamera->setFOVy(Radian(Degree(90 * mWindow->getHeight() / mWindow->getWidth())));
444                mCamera->setFarClipDistance(200);
445                mCamera->setNearClipDistance(0.1);
446
447                SceneNode* cn = mCamera->getParentSceneNode();
448
449                OgreIlluminationManager::getSingleton().setFocusingSM(false);
450           OgreIlluminationManager::getSingleton().setShadowMapSize(700);
451           OgreIlluminationManager::getSingleton().setBlurShadowMap(true);
452           OgreIlluminationManager::getSingleton().setShadowMapMaterialName("GTP/Basic/Distance_Normalized");
453            mSceneMgr->setAmbientLight(ColourValue(0.505 * 0.2, 0.897 * 0.2, 0.914 * 0.2));
454               
455                capture  = new FrameCapture(mWindow);
456                if(scene == 1) createScene1();
457                if(scene == 2) createScene2();
458                if(scene == 3) createScene3();
459
460                TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(  "SCREENSHOT",
461                                                                                                                                                                "default",
462                                                                                                                                                                TEX_TYPE_2D,
463                                                                                                                                                                1600,
464                                                                                                                                                                1200,
465                                                                                                                                                                0,
466                                                                                                                                                                0,
467                                                                                                                                                                PF_R8G8B8,
468                                                                                                                                                                TU_RENDERTARGET);
469                screenTexture = texPtr.getPointer();
470                RenderTexture* rt = screenTexture->getBuffer()->getRenderTarget();
471                Viewport* vp = rt->addViewport(mCamera);
472                rt->setAutoUpdated(false);
473                vp->setOverlaysEnabled(false);
474               
475
476                OgreIlluminationManager::getSingleton().initTechniques();
477        }
478   void createScene1(void)
479    {
480        SceneNode* rootNode = mSceneMgr->getRootSceneNode();
481               
482                mCamera->getParentSceneNode()->translate(0.944, 1.857, 1.054);
483                //mCamera->lookAt(Vector3(0.11, 1.043, -0.102));
484                       
485                object = mSceneMgr->createEntity("object", objectNames[currentObject]);
486                 
487                object->setMaterialName(materialNames[currentMaterial]);
488                objectNode = rootNode->createChildSceneNode("objectNode");
489                objectNode->attachObject(object);
490               
491                float scale = objectscales[currentObject] * scenescales[scene-1];
492                objectNode->scale(scale, scale, scale);         
493               
494                objectNode->setPosition(0.136, 1.032, 0.031);
495                objectNode->_updateBounds();
496
497                capture->addAnimableNode(objectNode);
498                capture->addAnimableNode(mCamera->getParentSceneNode());
499               
500                Entity* room = mSceneMgr->createEntity("scene", "difflab.mesh");
501                //room->setMaterialName("GameTools/Phong");
502                SceneNode* roomNode = rootNode->createChildSceneNode();
503                roomNode->attachObject(room);           
504                roomNode->_updateBounds();             
505
506                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
507       
508                Light* redLight1 = mSceneMgr->createLight("RedLight1");
509                redLight1->setType(Light::LT_POINT);
510                redLight1->setCastShadows(false);
511        redLight1->setDiffuseColour(ColourValue(1,0.055, 0.0));
512                redLight1->setPowerScale(1.6);
513                SceneNode* redLightNode1 = rootNode->createChildSceneNode();
514                redLightNode1->setPosition(0.05,2.361,-1.07);
515                redLightNode1->attachObject(redLight1);
516
517                Light* greenLight1 = mSceneMgr->createLight("GreenLight1");
518                greenLight1->setType(Light::LT_POINT);
519                greenLight1->setCastShadows(false);
520        greenLight1->setDiffuseColour(ColourValue(0.362,0.783, 0.685));
521                greenLight1->setPowerScale(2.0);
522                SceneNode* greenLightNode1 = rootNode->createChildSceneNode();
523                greenLightNode1->setPosition(1.312,1.313,0);
524                greenLightNode1->attachObject(greenLight1);
525
526                Light* mainBlueLight = mSceneMgr->createLight("MainBlueLight");
527                mainBlueLight->setType(Light::LT_SPOTLIGHT);
528                mainBlueLight->setCastShadows(true);
529        mainBlueLight->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
530                mainBlueLight->setPowerScale(3.0);
531                mainBlueLight->setSpotlightRange(Degree(0),Degree(160));
532                mainBlueLight->setAttenuation(2.5, 0, 1, 0);
533                SceneNode* mainBlueLightNode = rootNode->createChildSceneNode();
534                mainBlueLightNode->setPosition(-0.546,2.095,1.035);
535                //mainBlueLightNode->rotate(Vector3::UNIT_X, Degree(161.396));
536                //mainBlueLightNode->rotate(Vector3::UNIT_Y, Degree(53.955));
537                //mainBlueLightNode->rotate(Vector3::UNIT_Z, Degree(-145.065));
538                mainBlueLight->setDirection(-1.5,-2.0,1.0);
539                mainBlueLightNode->attachObject(mainBlueLight);
540/*
541                Light* mainLight = mSceneMgr->createLight("MainLight");
542                mainLight->setType(Light::LT_SPOTLIGHT);
543                mainLight->setSpotlightRange(Degree(0),Degree(160));
544                mainLight->setCastShadows(false);
545        mainLight->setDiffuseColour(ColourValue(0.995,0.996, 0.80));
546                mainLight->setPowerScale(1.0);
547                mainLight->setAttenuation(3, 0, 1, 0);
548                SceneNode* mainLightNode = rootNode->createChildSceneNode();
549                mainLightNode->setPosition(0,2.5,0);
550                mainLight->setDirection(0,-1.0,0);
551                mainLightNode->attachObject(mainLight);*/
552/*
553                BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
554                bbs->setDefaultDimensions(0.2, 0.2);
555                bbs->createBillboard(Vector3::ZERO, ColourValue::White);
556                bbs->setMaterialName("Flare");
557                mainLightNode->attachObject(bbs);*/
558   }
559
560        void createScene2(void)
561    {
562        SceneNode* rootNode = mSceneMgr->getRootSceneNode();
563               
564                mCamera->setPosition(2.3,7.0,2.3);
565                //mCamera->lookAt(Vector3(0,5.75,0.0));
566               
567                object = mSceneMgr->createEntity("object", "teapot.mesh");
568                object->setMaterialName("MetalTeapotMultipleBounce");
569                objectNode = rootNode->createChildSceneNode();
570                objectNode->attachObject(object);
571                //objectNode->scale(0.5,0.5,0.5);
572                //objectNode->scale(0.005,0.005,0.005);
573                objectNode->setPosition(0,5.75,0.0);
574                objectNode->_updateBounds();
575
576                Entity* room = mSceneMgr->createEntity("scene", "terito.mesh");
577                //room->setMaterialName("GameTools/Phong");
578                SceneNode* roomNode = rootNode->createChildSceneNode();
579                roomNode->attachObject(room);
580                roomNode->_updateBounds();             
581
582                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
583                Light* Light1 = mSceneMgr->createLight("Light1");
584                Light1->setType(Light::LT_POINT);
585                Light1->setCastShadows(false);
586        Light1->setDiffuseColour(ColourValue(1,1, 1));
587                Light1->setPowerScale(1.0);
588                SceneNode* LightNode1 = rootNode->createChildSceneNode();
589                LightNode1->setPosition(1.5,10.3,0);
590                LightNode1->attachObject(Light1);               
591   }
592               
593        void createScene3(void)
594    {     
595        SceneNode* rootNode = mSceneMgr->getRootSceneNode();
596               
597                //mCamera->getParentSceneNode()->translate(Vector3(6.564,4.328,0.059));
598                //mCamera->setPosition(4.0,4.2,-3.5);
599                //mCamera->getParentSceneNode()->translate(7.0,2.6,-0.5);
600                mCamera->setPosition(7.0,2.6,-0.5);
601                mCamera->lookAt(Vector3(1.0, 0.0,0.6));
602               
603                object = mSceneMgr->createEntity("object", objectNames[currentObject]);
604
605                object->setMaterialName(materialNames[currentMaterial]);
606                objectNode = rootNode->createChildSceneNode();
607                objectNode->attachObject(object);
608
609                float scale = objectscales[currentObject] * scenescales[scene-1];
610                objectNode->scale(scale, scale, scale);
611               
612                objectNode->_updateBounds();
613
614                Entity* room = mSceneMgr->createEntity("scene", "colorcube.mesh");
615                //room->setMaterialName("GameTools/Phong");
616                SceneNode* roomNode = rootNode->createChildSceneNode();
617                roomNode->attachObject(room);
618                roomNode->setScale(2,2,2);
619                roomNode->_updateBounds();
620
621                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
622                Light* Light1 = mSceneMgr->createLight("Light1");
623                Light1->setType(Light::LT_SPOTLIGHT);
624                Light1->setCastShadows(true);
625        Light1->setDiffuseColour(ColourValue(1,1, 1));
626                Light1->setPowerScale(1.0);
627                SceneNode* LightNode1 = rootNode->createChildSceneNode();
628                LightNode1->setPosition(3,3,3);
629                Light1->setDirection(-1,-1,-1);
630                Light1->setSpotlightRange(Degree(0),Degree(120));
631                LightNode1->attachObject(Light1);
632/*
633                BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
634                bbs->setDefaultDimensions(0.2, 0.2);
635                bbs->createBillboard(Vector3::ZERO, ColourValue::White);
636                bbs->setMaterialName("Flare");
637                LightNode1->attachObject(bbs);*/
638   }
639
640        void createFrameListener(void)
641    {
642                // This is where we instantiate our own frame listener
643                mFrameListener= new RaytraceDemoListener(mWindow, mCamera, objectNode, object);
644                mFrameListener->setPriority(1);
645                OgreIlluminationManager::getSingleton().setPriority(3);
646                capture->setPriority(2);
647        mRoot->addFrameListener(capture);
648                mRoot->addFrameListener(mFrameListener);
649                mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());
650
651    }
652
653};
654
Note: See TracBrowser for help on using the repository browser.