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

Revision 1611, 19.7 KB checked in by szirmay, 18 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#include "ExampleApplication.h"
27#include "OgreIlluminationManager.h"
28
29float causize = 10;
30float cauintens = 40;
31int scene = 1;
32// Listener class for frame updates
33class RaytraceDemoListener : public ExampleFrameListener
34{
35protected:
36       
37        SceneNode* objectNode;
38        unsigned long framecount;
39       
40public:
41    RaytraceDemoListener(RenderWindow* window, Camera* maincam, SceneNode* objectNode)
42        :ExampleFrameListener(window, maincam)
43                                 
44    {
45                this->mMoveSpeed = 2.0;
46                framecount = 0;
47                this->objectNode = objectNode;
48          }
49        bool processUnbufferedKeyInput(const FrameEvent& evt)
50    {
51                if (mInputDevice->isKeyDown(KC_UP))
52        {
53                        objectNode->translate(0,0,0.5);
54        }
55                if (mInputDevice->isKeyDown(KC_MULTIPLY))
56        {
57                        objectNode->scale(1.1,1.1,1.1);
58                        mTimeUntilNextToggle = 1;
59        }
60                if (mInputDevice->isKeyDown(KC_DIVIDE))
61        {
62                        objectNode->scale(1.0/1.1,1.0/1.1,1.0/1.1);
63                        mTimeUntilNextToggle = 1;
64        }
65                if (mInputDevice->isKeyDown(KC_ADD))
66        {
67                        objectNode->rotate(Vector3(0,1,0), Degree(10));
68        }
69                if (mInputDevice->isKeyDown(KC_DOWN))
70        {
71                        objectNode->translate(0,0,-0.5);
72        }
73                if (mInputDevice->isKeyDown(KC_RIGHT))
74        {
75                        objectNode->translate(0.5,0,0);
76        }
77                if (mInputDevice->isKeyDown(KC_LEFT))
78        {
79                        objectNode->translate(-0.5,0,0);
80        }
81
82                if (mInputDevice->isKeyDown(KC_A))
83        {
84            // Move camera left
85            mTranslateVector.x = -mMoveScale;
86        }
87
88        if (mInputDevice->isKeyDown(KC_D))
89        {
90            // Move camera RIGHT
91            mTranslateVector.x = mMoveScale;
92        }
93
94        /* Move camera forward by keypress. */
95        if ( mInputDevice->isKeyDown(KC_W) )
96        {
97            mTranslateVector.z = -mMoveScale;
98        }
99               
100        /* Move camera backward by keypress. */
101        if (mInputDevice->isKeyDown(KC_S) )
102        {
103            mTranslateVector.z = mMoveScale;
104        }
105
106        if (mInputDevice->isKeyDown(KC_PGUP))
107        {
108            // Move camera up
109            mTranslateVector.y = mMoveScale;
110        }
111
112        if (mInputDevice->isKeyDown(KC_PGDOWN))
113        {
114            // Move camera down
115            mTranslateVector.y = -mMoveScale;
116        }       
117
118        if( mInputDevice->isKeyDown( KC_ESCAPE) )
119        {           
120            return false;
121        }
122
123                // see if switching is on, and you want to toggle
124        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
125        {
126                        switchMouseMode();
127            mTimeUntilNextToggle = 1;
128        }
129
130        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_K) && mTimeUntilNextToggle <= 0)
131        {
132                        // must be going from immediate keyboard to buffered keyboard
133                        switchKeyMode();
134            mTimeUntilNextToggle = 1;
135        }
136        if (mInputDevice->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0)
137        {
138            mStatsOn = !mStatsOn;
139            showDebugOverlay(mStatsOn);
140
141            mTimeUntilNextToggle = 1;
142        }
143        if (mInputDevice->isKeyDown(KC_T) && mTimeUntilNextToggle <= 0)
144        {
145            switch(mFiltering)
146            {
147            case TFO_BILINEAR:
148                mFiltering = TFO_TRILINEAR;
149                mAniso = 1;
150                break;
151            case TFO_TRILINEAR:
152                mFiltering = TFO_ANISOTROPIC;
153                mAniso = 8;
154                break;
155            case TFO_ANISOTROPIC:
156                mFiltering = TFO_BILINEAR;
157                mAniso = 1;
158                break;
159            default:
160                break;
161            }
162            MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
163            MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
164
165
166            showDebugOverlay(mStatsOn);
167
168            mTimeUntilNextToggle = 1;
169        }
170
171        if (mInputDevice->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
172        {
173                        char tmp[20];
174                        sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
175            mWindow->writeContentsToFile(tmp);
176            mTimeUntilNextToggle = 0.5;
177                        mWindow->setDebugText(String("Wrote ") + tmp);
178        }
179               
180                if (mInputDevice->isKeyDown(KC_R) && mTimeUntilNextToggle <=0)
181                {
182                        mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
183                        switch(mSceneDetailIndex) {
184                                case 0 : mCamera->setPolygonMode(PM_SOLID) ; break ;
185                                case 1 : mCamera->setPolygonMode(PM_WIREFRAME) ; break ;
186                                case 2 : mCamera->setPolygonMode(PM_POINTS) ; break ;
187                        }
188                        mTimeUntilNextToggle = 0.5;
189                }
190
191        static bool displayCameraDetails = false;
192        if (mInputDevice->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
193        {
194            displayCameraDetails = !displayCameraDetails;
195            mTimeUntilNextToggle = 0.5;
196            if (!displayCameraDetails)
197                mWindow->setDebugText("");
198        }
199        if (displayCameraDetails)
200        {
201            // Print camera details
202            mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) + " " +
203                "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
204        }
205
206        // Return true to continue rendering
207        return true;
208        }
209    bool frameStarted(const FrameEvent& evt)
210    {
211                static bool first = true;
212       
213
214        //      lightNode->setPosition( 100.0 * Vector3(cos(-(float)framecount/500.0),2.0,sin(-(float)framecount/500.0)));
215               
216               
217                bool result = ExampleFrameListener::frameStarted(evt);
218       framecount++;
219      return result;     
220    }
221
222       
223
224};
225
226
227class FloorRenderTargetListener : public RenderTargetListener
228{
229public:
230        Entity* scene;
231        FloorRenderTargetListener(Entity* scene)
232        {
233                this->scene = scene;
234        }
235        void preRenderTargetUpdate(const RenderTargetEvent& evt)
236    {
237                scene->getSubEntity(0)->setVisible(false);
238                scene->getSubEntity(17)->setVisible(false);
239                scene->getSubEntity(35)->setVisible(false);
240                scene->getSubEntity(52)->setVisible(false);
241    }
242    void postRenderTargetUpdate(const RenderTargetEvent& evt)
243    {
244       scene->getSubEntity(0)->setVisible(true);
245                scene->getSubEntity(17)->setVisible(true);
246                scene->getSubEntity(35)->setVisible(true);
247                scene->getSubEntity(52)->setVisible(true);
248    }
249
250};
251
252class CeilRenderTargetListener : public RenderTargetListener
253{
254public:
255        Entity* scene;
256        CeilRenderTargetListener(Entity* scene)
257        {
258                this->scene = scene;
259        }
260        void preRenderTargetUpdate(const RenderTargetEvent& evt)
261    {
262                scene->getSubEntity(1)->setVisible(false);
263                scene->getSubEntity(18)->setVisible(false);
264                scene->getSubEntity(36)->setVisible(false);
265                scene->getSubEntity(53)->setVisible(false);
266    }
267    void postRenderTargetUpdate(const RenderTargetEvent& evt)
268    {
269       scene->getSubEntity(1)->setVisible(true);
270                scene->getSubEntity(18)->setVisible(true);
271                scene->getSubEntity(36)->setVisible(true);
272                scene->getSubEntity(53)->setVisible(true);
273    }
274
275};
276
277class ReflectionCameraFrameListener : public FrameListener
278{
279public:
280        Camera* floorReflCam;
281        Camera* ceilReflCam;
282        Camera* mainCamera;
283    ReflectionCameraFrameListener(Camera* floorcam, Camera* ceilCam, Camera* mainCam)
284        {
285                floorReflCam = floorcam;
286                ceilReflCam = ceilCam;
287                mainCamera = mainCam;
288        }
289        bool frameStarted(const FrameEvent& evt)
290    {
291                floorReflCam->setOrientation(mainCamera->getOrientation());
292        floorReflCam->setPosition(mainCamera->getPosition());
293
294        //      ceilReflCam->setOrientation(mainCamera->getOrientation());
295    //    ceilReflCam->setPosition(mainCamera->getPosition());
296
297                return true;
298        }
299};
300/** Application class */
301class RaytraceDemoApplication : public ExampleApplication
302{
303
304public:
305
306protected:
307        SceneNode* objectNode;
308
309        void createPostproc()
310        {
311                CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
312                                                                                                                "GameTools/Glow");
313                CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
314                                                                                                                "GameTools/Glow", true);
315
316        }
317   
318
319        void createScene(void)
320    {
321
322                //createPostproc();
323               
324                OgreIlluminationManager::getSingleton().setMainCamera(mCamera);
325                OgreIlluminationManager::getSingleton().setMainViewport(mWindow->getViewport(0));
326               
327                OgreIlluminationManager::getSingleton().setMaxJoinRadius(420);         
328
329                Root::getSingleton()._setCurrentSceneManager(mSceneMgr);
330
331                mCamera->setPosition(0,10,10);         
332                mCamera->setFOVy(Radian(Degree(80)));
333                mCamera->setFarClipDistance(200);
334                mCamera->setNearClipDistance(0.1);
335               
336                if(scene == 1)
337                createScene1();
338                else
339                createScene2();
340               
341                OgreIlluminationManager::getSingleton().initTechniques();
342               
343               
344   }
345
346   void createScene1()
347   {
348           
349        mSceneMgr->setAmbientLight(ColourValue(0.1, 0.0537, 0.0));
350                //mSceneMgr->setAmbientLight(ColourValue(0.0, 0.0, 0.0));
351                 
352
353                // Skybox
354        //mSceneMgr->setSkyBox(true, "Examples/MorningSkyBox");
355
356                SceneNode* rootNode = mSceneMgr->getRootSceneNode();
357
358        Entity* object = mSceneMgr->createEntity("object", "chinaman.mesh");
359                object->setMaterialName("GameTools/Diffuse/use");
360                //object->setMaterialName("GameTools/Diffuse2");
361                objectNode = rootNode->createChildSceneNode();
362                objectNode->attachObject(object);
363        //      objectNode->scale(0.05,0.05,0.05);
364                objectNode->scale(3,3,3);
365        //      objectNode->setPosition(0,4,0);                 
366                objectNode->_updateBounds();
367
368                Entity* room = mSceneMgr->createEntity("atlascube", "diffscene.mesh");
369                //room->setMaterialName("GameTools/Phong");
370                SceneNode* roomNode = rootNode->createChildSceneNode();
371                //roomNode->setScale(10,10,10);
372                roomNode->attachObject(room);
373                roomNode->_updateBounds();
374               
375                Light* bluelight = mSceneMgr->createLight("BlueLight");
376                bluelight->setType(Light::LT_POINT);
377        bluelight->setDiffuseColour(ColourValue(0.152,0.824, 1.0));
378                //bluelight->setSpecularColour(ColourValue(0.152,0.824, 1.0));
379                bluelight->setPowerScale(5.726);
380                bluelight->setAttenuation(12, 0, 1, 0);
381                SceneNode* bluelightNode = rootNode->createChildSceneNode();
382                bluelightNode->setPosition(-5.948,9.619,0.980);
383                bluelightNode->attachObject(bluelight);
384
385                Light* walllight1 = mSceneMgr->createLight("WallLight1");
386                walllight1->setType(Light::LT_POINT);
387        walllight1->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
388                //walllight1->setSpecularColour(ColourValue(0.988,1.0, 0.808));
389                walllight1->setPowerScale(2.5);
390                walllight1->setAttenuation(12, 0, 1, 0);
391                SceneNode* walllight1Node = rootNode->createChildSceneNode();
392                walllight1Node->setPosition(-4.822,9.353,-5.194);
393                walllight1Node->attachObject(walllight1);
394
395                Light* walllight2 = mSceneMgr->createLight("WallLight2");
396                walllight2->setType(Light::LT_POINT);
397        walllight2->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
398                //walllight2->setSpecularColour(ColourValue(0.988,1.0, 0.808));
399                walllight2->setPowerScale(2.5);
400                walllight2->setAttenuation(12, 0, 1, 0);
401                SceneNode* walllight2Node = rootNode->createChildSceneNode();
402                walllight2Node->setPosition(-4.822,9.353,5.150);
403                walllight2Node->attachObject(walllight2);
404
405                Light* walllight3 = mSceneMgr->createLight("WallLight3");
406                walllight3->setType(Light::LT_POINT);
407        walllight3->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
408                //walllight3->setSpecularColour(ColourValue(0.988,1.0, 0.808));
409                walllight3->setPowerScale(2.5);
410                walllight3->setAttenuation(12, 0, 1, 0);
411                SceneNode* walllight3Node = rootNode->createChildSceneNode();
412                walllight3Node->setPosition(-11.08,10.07,-24.658);
413                walllight3Node->attachObject(walllight3);
414
415                Light* walllight4 = mSceneMgr->createLight("WallLight4");
416                walllight4->setType(Light::LT_POINT);
417        walllight4->setDiffuseColour(ColourValue(0.988,1.0, 0.808));
418                //walllight4->setSpecularColour(ColourValue(0.988,1.0, 0.808));
419                walllight4->setPowerScale(2.5);
420                walllight4->setAttenuation(12, 0, 1, 0);
421                SceneNode* walllight4Node = rootNode->createChildSceneNode();
422                walllight4Node->setPosition(-11.08,10.07,-11.474);
423                walllight4Node->attachObject(walllight4);
424
425                Light* redlight1 = mSceneMgr->createLight("RedLight1");
426                redlight1->setType(Light::LT_POINT);
427        redlight1->setDiffuseColour(ColourValue(1.0,0.367, 0.016));
428                //redlight1->setSpecularColour(ColourValue(1.0,0.367, 0.016));
429                redlight1->setPowerScale(3.59);
430                redlight1->setAttenuation(2, 0, 1, 0);
431                SceneNode* redlight1Node = rootNode->createChildSceneNode();
432                redlight1Node->setPosition(24.958,7.743,-10.838);
433                redlight1Node->attachObject(redlight1);
434
435                Light* redlight2 = mSceneMgr->createLight("RedLight2");
436                redlight2->setType(Light::LT_POINT);
437        redlight2->setDiffuseColour(ColourValue(1.0,0.367, 0.016));
438                //redlight2->setSpecularColour(ColourValue(1.0,0.367, 0.016));
439                redlight2->setPowerScale(3.59);
440                redlight2->setAttenuation(2, 0, 1, 0);
441                SceneNode* redlight2Node = rootNode->createChildSceneNode();
442                redlight2Node->setPosition(18.689,7.743,-10.838);
443                redlight2Node->attachObject(redlight2);
444   }
445
446   Camera* mReflectCamFloor;
447   Camera* mReflectCamCeil;
448   ReflectionCameraFrameListener* reflListener;
449   void createScene2()
450   {
451           mCamera->setPosition(0,5,10);
452           MovablePlane *floorPlane = new MovablePlane("ReflectPlaneFloor");
453        floorPlane->d = 0;
454        floorPlane->normal = Vector3::UNIT_Y;
455
456                RenderTexture* rttTexFloor = mRoot->getRenderSystem()->createRenderTexture( "FloorReflection", 512, 512, TEX_TYPE_2D, PF_R8G8B8 );
457        {
458            mReflectCamFloor = mSceneMgr->createCamera("ReflectCamFloor");
459            mReflectCamFloor->setNearClipDistance(mCamera->getNearClipDistance());
460            mReflectCamFloor->setFarClipDistance(mCamera->getFarClipDistance());
461           /* mReflectCamFloor->setAspectRatio(
462                (Real)mWindow->getViewport(0)->getActualWidth() /
463                (Real)mWindow->getViewport(0)->getActualHeight());*/
464                        mReflectCamFloor->setFOVy(mCamera->getFOVy());
465                        mReflectCamFloor->setAspectRatio(mCamera->getAspectRatio());
466
467            Viewport *v = rttTexFloor->addViewport( mReflectCamFloor );
468            v->setClearEveryFrame( true );
469            v->setBackgroundColour( ColourValue::Black );
470                       
471         
472            // set up linked reflection
473            mReflectCamFloor->enableReflection(floorPlane);
474            // Also clip
475            mReflectCamFloor->enableCustomNearClipPlane(floorPlane);
476        }
477        /*      MovablePlane *ceilPlane = new MovablePlane("ReflectPlaneCeil");
478        ceilPlane->d = -8;
479                ceilPlane->normal = Vector3::NEGATIVE_UNIT_Y;
480                RenderTexture* rttTexCeil = mRoot->getRenderSystem()->createRenderTexture( "CeilReflection", 512, 512, TEX_TYPE_2D, PF_R8G8B8 );
481        {
482            mReflectCamCeil = mSceneMgr->createCamera("ReflectCamCeil");
483            mReflectCamCeil->setNearClipDistance(mCamera->getNearClipDistance());
484            mReflectCamCeil->setFarClipDistance(mCamera->getFarClipDistance());
485            mReflectCamCeil->setAspectRatio(
486                (Real)mWindow->getViewport(0)->getActualWidth() /
487                (Real)mWindow->getViewport(0)->getActualHeight());
488
489            Viewport *v = rttTexCeil->addViewport( mReflectCamCeil );
490            v->setClearEveryFrame( true );
491            v->setBackgroundColour( ColourValue::Black );
492                       
493           
494            // set up linked reflection
495            mReflectCamCeil->enableReflection(floorPlane);
496            // Also clip
497            mReflectCamCeil->enableCustomNearClipPlane(floorPlane);
498        }
499                */
500                reflListener = new ReflectionCameraFrameListener(mReflectCamFloor, mReflectCamCeil, mCamera);
501                reflListener->setPriority(2);
502
503           // mSceneMgr->setAmbientLight(ColourValue(0.1, 0.0537, 0.0));
504           mSceneMgr->setAmbientLight(ColourValue(0.0, 0.0, 0.0));
505               
506                SceneNode* rootNode = mSceneMgr->getRootSceneNode();
507
508        Entity* object = mSceneMgr->createEntity("object", "athene.mesh");
509                object->setMaterialName("GameTools/Diffuse/use");
510                //object->setMaterialName("GameTools/Diffuse2");
511                objectNode = rootNode->createChildSceneNode();
512                objectNode->attachObject(object);
513                objectNode->scale(0.05,0.05,0.05);
514                objectNode->setPosition(0,4,0);
515                objectNode->_updateBounds();
516
517                Entity* room = mSceneMgr->createEntity("scene", "uvegfolyoso2.mesh");
518                //room->setMaterialName("GameTools/Phong");
519                SceneNode* roomNode = rootNode->createChildSceneNode();
520                roomNode->attachObject(room);
521                roomNode->_updateBounds();
522                rttTexFloor->addListener(new FloorRenderTargetListener(room));
523                //rttTexCeil->addListener(new CeilRenderTargetListener(room));
524
525                Light* light1 = mSceneMgr->createLight("Light1");
526                light1->setType(Light::LT_POINT);
527        light1->setDiffuseColour(ColourValue(0.526,0.535, 0.974));
528                light1->setPowerScale(3);
529                SceneNode* lightNode1 = rootNode->createChildSceneNode();
530                lightNode1->setPosition(-1.266,4.131,-4.438);
531                lightNode1->attachObject(light1);
532
533                Light* light2 = mSceneMgr->createLight("Light2");
534                light2->setType(Light::LT_POINT);
535        light2->setDiffuseColour(ColourValue(0.391,0.781, 0.974));
536                light2->setPowerScale(3);
537                SceneNode* lightNode2 = rootNode->createChildSceneNode();
538                lightNode2->setPosition(-33.537,4.131,-4.438);
539                lightNode2->attachObject(light2);
540
541                Light* light3 = mSceneMgr->createLight("Light3");
542                light3->setType(Light::LT_POINT);
543        light3->setDiffuseColour(ColourValue(0.391,0.781, 0.974));
544                light3->setPowerScale(3);
545                SceneNode* lightNode3 = rootNode->createChildSceneNode();
546                lightNode3->setPosition(-97.446,4.131,-4.438);
547                lightNode3->attachObject(light3);
548
549                Light* light4 = mSceneMgr->createLight("Light4");
550                light4->setType(Light::LT_POINT);
551        light4->setDiffuseColour(ColourValue(0.304,0.974, 0.770));
552                light4->setPowerScale(3);
553                SceneNode* lightNode4 = rootNode->createChildSceneNode();
554                lightNode4->setPosition(-63.277,4.131,-4.438);
555                lightNode4->attachObject(light4);
556
557               
558
559
560
561   }
562
563   void createPlane(Ogre::String _name, Ogre::String _material, Ogre::Vector3 _pos, Ogre::Vector2 _size, Ogre::Vector2 _subdivisions = Ogre::Vector2(1,1)) {
564               
565           Plane _plane;
566        _plane.normal = Vector3::UNIT_Y;
567        _plane.d = 0;
568
569
570        MeshManager::getSingleton().createPlane(_name + ".plane",
571            ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
572            _plane,_size.x,_size.y,1,1,true,1,_subdivisions.x,_subdivisions.y,Vector3::UNIT_Z);
573       
574                Entity *_entity = mSceneMgr->createEntity(_name + ".entity", _name + ".plane");
575        _entity->setMaterialName(_material);
576
577                SceneNode* _node = mSceneMgr->getRootSceneNode()->createChildSceneNode(_name + ".node");
578                _node->attachObject(_entity);
579                _node->setPosition(_pos);
580        }
581
582
583
584        void createFrameListener(void)
585    {
586                // This is where we instantiate our own frame listener
587                mFrameListener= new RaytraceDemoListener(mWindow,
588                                                                                        mCamera,
589                                                                                        objectNode
590                                                                                        );
591                mFrameListener->setPriority(1);
592                OgreIlluminationManager::getSingleton().setPriority(10);
593        mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());
594                mRoot->addFrameListener(mFrameListener);
595                if(scene == 2)
596                mRoot->addFrameListener(reflListener);
597       
598    }
599
600};
601
602
Note: See TracBrowser for help on using the repository browser.