source: GTP/branches/IllumWPdeliver2008dec/IlluminationWP/demos/OgreDemos/src/ReflectionTest/include/ReflectionTest.h @ 3255

Revision 3255, 21.4 KB checked in by szirmay, 15 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.8;
35int scene = 2;
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_Triangles_clone_object_SE_0");
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_Triangles_clone_object_SE_0");
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_Triangles_clone_object_SE_0");
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.01;
179
180                        MaterialPtr mat1 = MaterialManager::getSingleton().getByName(materialNames[currentMaterial]+"_clone_object_SE_0");
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.01;
197                       
198                        MaterialPtr mat1 = MaterialManager::getSingleton().getByName(materialNames[currentMaterial]+"_clone_object_SE_0");
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       
459                TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(  "SCREENSHOT",
460                                                                                                                                                                "default",
461                                                                                                                                                                TEX_TYPE_2D,
462                                                                                                                                                                1600,
463                                                                                                                                                                1200,
464                                                                                                                                                                0,
465                                                                                                                                                                0,
466                                                                                                                                                                PF_R8G8B8,
467                                                                                                                                                                TU_RENDERTARGET);
468                screenTexture = texPtr.getPointer();
469                RenderTexture* rt = screenTexture->getBuffer()->getRenderTarget();
470                Viewport* vp = rt->addViewport(mCamera);
471                rt->setAutoUpdated(false);
472                vp->setOverlaysEnabled(false);
473               
474
475                OgreIlluminationManager::getSingleton().initTechniques();
476        }
477   void createScene1(void)
478    {
479        SceneNode* rootNode = mSceneMgr->getRootSceneNode();
480               
481                mCamera->getParentSceneNode()->translate(0.944, 1.857, 1.054);
482                //mCamera->lookAt(Vector3(0.11, 1.043, -0.102));
483                       
484                object = mSceneMgr->createEntity("object", objectNames[currentObject]);
485                 
486                object->setMaterialName(materialNames[currentMaterial]);
487                objectNode = rootNode->createChildSceneNode("objectNode");
488                objectNode->attachObject(object);
489               
490                float scale = objectscales[currentObject] * scenescales[scene-1];
491                objectNode->scale(scale, scale, scale);         
492               
493                objectNode->setPosition(0.136, 1.032, 0.031);
494                objectNode->_updateBounds();
495
496                capture->addAnimableNode(objectNode);
497                capture->addAnimableNode(mCamera->getParentSceneNode());
498               
499                Entity* room = mSceneMgr->createEntity("scene", "difflab.mesh");
500                //room->setMaterialName("GameTools/Phong");
501                SceneNode* roomNode = rootNode->createChildSceneNode();
502                roomNode->attachObject(room);           
503                roomNode->_updateBounds();             
504
505                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
506       
507                Light* redLight1 = mSceneMgr->createLight("RedLight1");
508                redLight1->setType(Light::LT_POINT);
509                redLight1->setCastShadows(false);
510        redLight1->setDiffuseColour(ColourValue(1,0.055, 0.0));
511                redLight1->setPowerScale(1.6);
512                SceneNode* redLightNode1 = rootNode->createChildSceneNode();
513                redLightNode1->setPosition(0.05,2.361,-1.07);
514                redLightNode1->attachObject(redLight1);
515
516                Light* greenLight1 = mSceneMgr->createLight("GreenLight1");
517                greenLight1->setType(Light::LT_POINT);
518                greenLight1->setCastShadows(false);
519        greenLight1->setDiffuseColour(ColourValue(0.362,0.783, 0.685));
520                greenLight1->setPowerScale(2.0);
521                SceneNode* greenLightNode1 = rootNode->createChildSceneNode();
522                greenLightNode1->setPosition(1.312,1.313,0);
523                greenLightNode1->attachObject(greenLight1);
524
525                Light* mainBlueLight = mSceneMgr->createLight("MainBlueLight");
526                mainBlueLight->setType(Light::LT_SPOTLIGHT);
527                mainBlueLight->setCastShadows(true);
528        mainBlueLight->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
529                mainBlueLight->setPowerScale(3.0);
530                mainBlueLight->setSpotlightRange(Degree(0),Degree(160));
531                mainBlueLight->setAttenuation(2.5, 0, 1, 0);
532                SceneNode* mainBlueLightNode = rootNode->createChildSceneNode();
533                mainBlueLightNode->setPosition(-0.546,2.095,1.035);
534                mainBlueLightNode->rotate(Vector3::UNIT_X, Degree(161.396));
535                mainBlueLightNode->rotate(Vector3::UNIT_Y, Degree(53.955));
536                mainBlueLightNode->rotate(Vector3::UNIT_Z, Degree(-145.065));
537                mainBlueLight->setDirection(-1.5,-2.0,1.0);
538                mainBlueLightNode->attachObject(mainBlueLight);
539
540                Light* mainLight = mSceneMgr->createLight("MainLight");
541                mainLight->setType(Light::LT_SPOTLIGHT);
542                mainLight->setSpotlightRange(Degree(0),Degree(160));
543                mainLight->setCastShadows(false);
544        mainLight->setDiffuseColour(ColourValue(0.995,0.996, 0.80));
545                mainLight->setPowerScale(1.0);
546                mainLight->setAttenuation(3, 0, 1, 0);
547                SceneNode* mainLightNode = rootNode->createChildSceneNode();
548                mainLightNode->setPosition(0,2.5,0);
549                mainLight->setDirection(0,-1.0,0);
550                mainLightNode->attachObject(mainLight);
551
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->getParentSceneNode()->translate(Vector3(6.564,4.328,0.059));
565                //mCamera->setPosition(4.0,4.2,-3.5);
566                //mCamera->getParentSceneNode()->translate(7.0,2.6,-0.5);
567                mCamera->setPosition(7.0,2.6,-0.5);
568                mCamera->lookAt(Vector3(1.0, 0.0,0.6));
569               
570                object = mSceneMgr->createEntity("object", objectNames[currentObject]);
571
572                object->setMaterialName(materialNames[currentMaterial]);
573                objectNode = rootNode->createChildSceneNode();
574                objectNode->attachObject(object);
575
576                float scale = objectscales[currentObject] * scenescales[scene-1];
577                objectNode->scale(scale, scale, scale);
578               
579                objectNode->_updateBounds();
580
581                Entity* room = mSceneMgr->createEntity("scene", "colorcube.mesh");
582                //room->setMaterialName("GameTools/Phong");
583                SceneNode* roomNode = rootNode->createChildSceneNode();
584                roomNode->attachObject(room);
585                roomNode->setScale(1,1,1);
586                roomNode->_updateBounds();
587
588                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
589                Light* Light1 = mSceneMgr->createLight("Light1");
590                Light1->setType(Light::LT_SPOTLIGHT);
591                Light1->setCastShadows(true);
592        Light1->setDiffuseColour(ColourValue(1,1, 1));
593                Light1->setPowerScale(1.0);
594                SceneNode* LightNode1 = rootNode->createChildSceneNode();
595                LightNode1->setPosition(3,3,3);
596                Light1->setDirection(-1,-1,-1);
597                Light1->setSpotlightRange(Degree(0),Degree(120));
598                LightNode1->attachObject(Light1);
599/*
600                BillboardSet* bbs = mSceneMgr->createBillboardSet("bb", 1);
601                bbs->setDefaultDimensions(0.2, 0.2);
602                bbs->createBillboard(Vector3::ZERO, ColourValue::White);
603                bbs->setMaterialName("Flare");
604                LightNode1->attachObject(bbs);*/
605   }
606
607        void createFrameListener(void)
608    {
609                // This is where we instantiate our own frame listener
610                mFrameListener= new RaytraceDemoListener(mWindow, mCamera, objectNode, object);
611                mFrameListener->setPriority(1);
612                OgreIlluminationManager::getSingleton().setPriority(3);
613                capture->setPriority(2);
614        mRoot->addFrameListener(capture);
615                mRoot->addFrameListener(mFrameListener);
616                mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());
617
618    }
619
620};
621
Note: See TracBrowser for help on using the repository browser.