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

Revision 3255, 18.2 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#include "ExampleApplication.h"
27#include "OgreIlluminationManager.h"
28#include "FrameCapture.h"
29
30FrameCapture* capture;
31int scene = 3;
32
33int currentmaterial = 3;
34String materials[] = {"GTP/Diffuse/Point2Point",
35                "GTP/Diffuse/Disc2Point",
36                "GTP/Diffuse/Poly2Point",
37                "GTP/Glossy/Disc2Point"};
38
39// Listener class for frame updates
40class RaytraceDemoListener : public ExampleFrameListener
41{
42protected:
43       
44        SceneNode* objectNode;
45        unsigned long framecount;
46       
47public:
48    RaytraceDemoListener(RenderWindow* window, Camera* maincam, SceneNode* objectNode)
49        :ExampleFrameListener(window, maincam)
50                                 
51    {
52                this->mMoveSpeed = 2.0;
53                framecount = 0;
54                this->objectNode = objectNode;
55          }
56
57        void moveCamera()
58    {/*
59           mCamera->yaw(mRotX);
60       mCamera->pitch(mRotY);
61       mCamera->moveRelative(mTranslateVector);*/
62
63                mCamera->getParentSceneNode()->yaw(mRotX, Node::TransformSpace::TS_WORLD);
64                mCamera->getParentSceneNode()->pitch(mRotY, Node::TransformSpace::TS_LOCAL);
65                mCamera->getParentSceneNode()->translate(mTranslateVector, Node::TransformSpace::TS_LOCAL);
66               
67    }
68
69        bool processUnbufferedKeyInput(const FrameEvent& evt)
70    {
71                static float lastTime = 0.0;
72                float thisTime = (float) Root::getSingleton().getTimer()->getMilliseconds() / 1000.0f;
73                float elapsed = thisTime - lastTime;
74                float move = elapsed * 0.25;
75                float rotate = 80.0 * move;
76               
77                if (mInputDevice->isKeyDown(KC_UP))
78        {
79                        objectNode->translate(0,0,move);
80        }
81                if (mInputDevice->isKeyDown(KC_MULTIPLY))
82        {
83                        //objectNode->scale(1.1,1.1,1.1);
84                        objectNode->rotate(Vector3(0,0,1), Degree(rotate));
85                        mTimeUntilNextToggle = 1;
86        }
87                if (mInputDevice->isKeyDown(KC_DIVIDE))
88        {
89                        //objectNode->scale(1.0/1.1,1.0/1.1,1.0/1.1);
90                        objectNode->rotate(Vector3(1,0,0), Degree(rotate));
91                        mTimeUntilNextToggle = 1;
92        }
93                if (mInputDevice->isKeyDown(KC_ADD))
94        {
95                        objectNode->rotate(Vector3(0,1,0), Degree(rotate));
96        }
97                if (mInputDevice->isKeyDown(KC_HOME))
98        {
99                        objectNode->translate(0,move,0);
100        }
101                if (mInputDevice->isKeyDown(KC_END))
102        {
103                        objectNode->translate(0,-move,0);
104        }
105                if (mInputDevice->isKeyDown(KC_DOWN))
106        {
107                        objectNode->translate(0,0,-move);
108        }
109                if (mInputDevice->isKeyDown(KC_RIGHT))
110        {
111                        objectNode->translate(move,0,0);
112        }
113                if (mInputDevice->isKeyDown(KC_LEFT))
114        {
115                        objectNode->translate(-move,0,0);
116        }
117
118                if (mInputDevice->isKeyDown(KC_A))
119        {
120            // Move camera left
121            mTranslateVector.x = -mMoveScale;
122        }
123
124        if (mInputDevice->isKeyDown(KC_D))
125        {
126            // Move camera RIGHT
127            mTranslateVector.x = mMoveScale;
128        }
129
130        /* Move camera forward by keypress. */
131        if ( mInputDevice->isKeyDown(KC_W) )
132        {
133            mTranslateVector.z = -mMoveScale;
134        }
135               
136        /* Move camera backward by keypress. */
137        if (mInputDevice->isKeyDown(KC_S) )
138        {
139            mTranslateVector.z = mMoveScale;
140        }
141
142        if (mInputDevice->isKeyDown(KC_PGUP))
143        {
144            // Move camera up
145            mTranslateVector.y = mMoveScale;
146        }
147
148        if (mInputDevice->isKeyDown(KC_PGDOWN))
149        {
150            // Move camera down
151            mTranslateVector.y = -mMoveScale;
152        }       
153
154        if( mInputDevice->isKeyDown( KC_ESCAPE) )
155        {           
156            return false;
157        }
158
159                // see if switching is on, and you want to toggle
160        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
161        {
162                        switchMouseMode();
163            mTimeUntilNextToggle = 1;
164        }
165
166        if (mInputTypeSwitchingOn && mInputDevice->isKeyDown(KC_K) && mTimeUntilNextToggle <= 0)
167        {
168                        // must be going from immediate keyboard to buffered keyboard
169                        switchKeyMode();
170            mTimeUntilNextToggle = 1;
171        }
172        if (mInputDevice->isKeyDown(KC_F) && mTimeUntilNextToggle <= 0)
173        {
174            mStatsOn = !mStatsOn;
175            showDebugOverlay(mStatsOn);
176
177            mTimeUntilNextToggle = 1;
178        }
179        if (mInputDevice->isKeyDown(KC_T) && mTimeUntilNextToggle <= 0)
180        {
181            switch(mFiltering)
182            {
183            case TFO_BILINEAR:
184                mFiltering = TFO_TRILINEAR;
185                mAniso = 1;
186                break;
187            case TFO_TRILINEAR:
188                mFiltering = TFO_ANISOTROPIC;
189                mAniso = 8;
190                break;
191            case TFO_ANISOTROPIC:
192                mFiltering = TFO_BILINEAR;
193                mAniso = 1;
194                break;
195            default:
196                break;
197            }
198            MaterialManager::getSingleton().setDefaultTextureFiltering(mFiltering);
199            MaterialManager::getSingleton().setDefaultAnisotropy(mAniso);
200
201
202            showDebugOverlay(mStatsOn);
203
204            mTimeUntilNextToggle = 1;
205        }
206
207        if (mInputDevice->isKeyDown(KC_SYSRQ) && mTimeUntilNextToggle <= 0)
208        {
209                        char tmp[20];
210                        sprintf(tmp, "screenshot_%d.png", ++mNumScreenShots);
211            mWindow->writeContentsToFile(tmp);
212            mTimeUntilNextToggle = 0.5;
213                        mWindow->setDebugText(String("Wrote ") + tmp);
214        }
215               
216                if (mInputDevice->isKeyDown(KC_R) && mTimeUntilNextToggle <=0)
217                {
218                        mSceneDetailIndex = (mSceneDetailIndex+1)%3 ;
219                        switch(mSceneDetailIndex) {
220                                case 0 : mCamera->setPolygonMode(PM_SOLID) ; break ;
221                                case 1 : mCamera->setPolygonMode(PM_WIREFRAME) ; break ;
222                                case 2 : mCamera->setPolygonMode(PM_POINTS) ; break ;
223                        }
224                        mTimeUntilNextToggle = 0.5;
225                }
226
227        static bool displayCameraDetails = false;
228        if (mInputDevice->isKeyDown(KC_P) && mTimeUntilNextToggle <= 0)
229        {
230            displayCameraDetails = !displayCameraDetails;
231            mTimeUntilNextToggle = 0.5;
232            if (!displayCameraDetails)
233                mWindow->setDebugText("");
234        }
235        if (displayCameraDetails)
236        {
237            // Print camera details
238            mWindow->setDebugText("P: " + StringConverter::toString(mCamera->getDerivedPosition()) + " " +
239                "O: " + StringConverter::toString(mCamera->getDerivedOrientation()));
240        }
241        if (mInputDevice->isKeyDown(KC_N) && mTimeUntilNextToggle <= 0)
242        {
243                        capture->playEvent();
244            mTimeUntilNextToggle = 1;
245        }
246                if (mInputDevice->isKeyDown(KC_B) && mTimeUntilNextToggle <= 0)
247        {
248                        capture->recordEvent();
249            mTimeUntilNextToggle = 1;
250        }
251                if (mInputDevice->isKeyDown(KC_M) && mTimeUntilNextToggle <= 0)
252        {
253                        capture->setSaving();
254                        capture->playEvent();
255            mTimeUntilNextToggle = 1;
256        }
257
258                lastTime = thisTime;
259        // Return true to continue rendering
260        return true;
261        }
262    bool frameStarted(const FrameEvent& evt)
263    {
264                static bool first = true;
265       
266
267        //      lightNode->setPosition( 100.0 * Vector3(cos(-(float)framecount/500.0),2.0,sin(-(float)framecount/500.0)));
268               
269               
270                bool result = ExampleFrameListener::frameStarted(evt);
271       framecount++;
272      return result;     
273    }
274
275       
276
277};
278
279
280class FloorRenderTargetListener : public RenderTargetListener
281{
282public:
283        Entity* scene;
284        FloorRenderTargetListener(Entity* scene)
285        {
286                this->scene = scene;
287        }
288        void preRenderTargetUpdate(const RenderTargetEvent& evt)
289    {
290                scene->getSubEntity(0)->setVisible(false);
291                scene->getSubEntity(17)->setVisible(false);
292                scene->getSubEntity(35)->setVisible(false);
293                scene->getSubEntity(52)->setVisible(false);
294    }
295    void postRenderTargetUpdate(const RenderTargetEvent& evt)
296    {
297       scene->getSubEntity(0)->setVisible(true);
298                scene->getSubEntity(17)->setVisible(true);
299                scene->getSubEntity(35)->setVisible(true);
300                scene->getSubEntity(52)->setVisible(true);
301    }
302
303};
304
305class CeilRenderTargetListener : public RenderTargetListener
306{
307public:
308        Entity* scene;
309        CeilRenderTargetListener(Entity* scene)
310        {
311                this->scene = scene;
312        }
313        void preRenderTargetUpdate(const RenderTargetEvent& evt)
314    {
315                scene->getSubEntity(1)->setVisible(false);
316                scene->getSubEntity(18)->setVisible(false);
317                scene->getSubEntity(36)->setVisible(false);
318                scene->getSubEntity(53)->setVisible(false);
319    }
320    void postRenderTargetUpdate(const RenderTargetEvent& evt)
321    {
322       scene->getSubEntity(1)->setVisible(true);
323                scene->getSubEntity(18)->setVisible(true);
324                scene->getSubEntity(36)->setVisible(true);
325                scene->getSubEntity(53)->setVisible(true);
326    }
327
328};
329
330class ReflectionCameraFrameListener : public FrameListener
331{
332public:
333        Camera* floorReflCam;
334        Camera* ceilReflCam;
335        Camera* mainCamera;
336    ReflectionCameraFrameListener(Camera* floorcam, Camera* ceilCam, Camera* mainCam)
337        {
338                floorReflCam = floorcam;
339                ceilReflCam = ceilCam;
340                mainCamera = mainCam;
341        }
342        bool frameStarted(const FrameEvent& evt)
343    {
344                floorReflCam->setOrientation(mainCamera->getOrientation());
345        floorReflCam->setPosition(mainCamera->getPosition());
346
347        //      ceilReflCam->setOrientation(mainCamera->getOrientation());
348    //    ceilReflCam->setPosition(mainCamera->getPosition());
349
350                return true;
351        }
352};
353/** Application class */
354class RaytraceDemoApplication : public ExampleApplication
355{
356
357public:
358
359protected:
360        SceneNode* objectNode;
361
362        void loadResources(void)
363        {
364                // Initialise, parse scripts etc
365                ResourceGroupManager::getSingleton().initialiseResourceGroup("Bootstrap");
366                ResourceGroupManager::getSingleton().initialiseResourceGroup("General");
367                ResourceGroupManager::getSingleton().initialiseResourceGroup("PostProc");
368                ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Basic");
369                //ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Diffuse_Simple");
370                ResourceGroupManager::getSingleton().initialiseResourceGroup("GTP_Diffuse");
371        }
372
373        void createPostproc()
374        {               
375                CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
376                                                                                                                "GTP/PostProc/Glow");
377                CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
378                                                                                                                "GTP/PostProc/Glow", true);
379
380                CompositorManager::getSingleton().addCompositor(mWindow->getViewport(0),
381                                                                                                                "GTP/PostProc/ToneMap");
382                CompositorManager::getSingleton().setCompositorEnabled(mWindow->getViewport(0),
383                                                                                                                "GTP/PostProc/ToneMap", true);         
384        }
385
386        void chooseSceneManager()
387        {
388                mSceneMgr = mRoot->createSceneManager("OctreeSceneManager");
389                //mSceneMgr = mRoot->createSceneManager("OcclusionCullingSceneManager");
390        }
391   
392        void createCamera(void)
393    {
394        // Create the camera
395        mCamera = mSceneMgr->createCamera("PlayerCam");
396               
397                SceneNode* camNode = mSceneMgr->getRootSceneNode()->createChildSceneNode("mainCameraNode");
398                camNode->attachObject(mCamera);
399       //camNode->setPosition(Vector3(0,1,0));
400        // Position it at 500 in Z direction
401        //mCamera->setPosition(Vector3(0,0,500));
402        // Look back along -Z
403        //mCamera->lookAt(Vector3(0,0,-300));
404        mCamera->setNearClipDistance(5);
405
406    }
407
408        void createScene(void)
409    {
410                //std::string occlusion_cfg("OcclusionCulling.cfg");
411                //mSceneMgr->setWorldGeometry(occlusion_cfg);
412                //createPostproc();
413               
414                OgreIlluminationManager::getSingleton().setMainCamera(mCamera);
415                OgreIlluminationManager::getSingleton().setMainViewport(mWindow->getViewport(0));
416               
417                OgreIlluminationManager::getSingleton().setMaxJoinRadius(420);         
418
419                Root::getSingleton()._setCurrentSceneManager(mSceneMgr);
420
421                //mCamera->setPosition(0,1,0);         
422                mCamera->setFOVy(Radian(Degree(80)));
423                mCamera->setFarClipDistance(200);
424                mCamera->setNearClipDistance(0.1);
425               
426                capture  = new FrameCapture(mWindow);
427               
428                createScene1();
429               
430                OgreIlluminationManager::getSingleton().initTechniques();
431               
432               
433   }
434
435 
436
437   void createScene1()
438   {
439           OgreIlluminationManager::getSingleton().setFocusingSM(false);
440           OgreIlluminationManager::getSingleton().setShadowMapSize(512);
441           OgreIlluminationManager::getSingleton().setBlurShadowMap(true);
442           OgreIlluminationManager::getSingleton().setShadowMapMaterialName("GTP/Basic/Distance_Normalized");//GameTools/ShadowMapDistance
443            mSceneMgr->setAmbientLight(ColourValue(0.505 * 0.2, 0.897 * 0.2, 0.914 * 0.2));
444               
445                SceneNode* rootNode = mSceneMgr->getRootSceneNode();
446
447        Entity* object = mSceneMgr->createEntity("object", "buddha.mesh");
448                        object->setMaterialName(materials[currentmaterial]);
449               
450                objectNode = rootNode->createChildSceneNode();
451                objectNode->attachObject(object);
452                objectNode->scale(0.4,0.4,0.4);
453                objectNode->rotate(Vector3(0,1,0),Radian(Math::PI));
454                objectNode->setPosition(0,1,0);
455                objectNode->_updateBounds();
456
457                Entity* room = mSceneMgr->createEntity("scene", "difflab.mesh");
458                //room->setMaterialName("GameTools/Phong");
459                SceneNode* roomNode = rootNode->createChildSceneNode();
460                roomNode->attachObject(room);
461                roomNode->_updateBounds();     
462
463
464                capture->addAnimableNode(objectNode);
465                capture->addAnimableNode(mCamera->getParentSceneNode());
466
467                mSceneMgr->setShadowTechnique(SHADOWTYPE_NONE);
468                Light* redLight1 = mSceneMgr->createLight("RedLight1");
469                redLight1->setType(Light::LT_POINT);
470                redLight1->setCastShadows(false);
471        redLight1->setDiffuseColour(ColourValue(1,0.055, 0.0));
472                redLight1->setPowerScale(1.6);
473                //redLight1->setPowerScale(0.6);
474                redLight1->setAttenuation(20, 0, 0, 3);
475                SceneNode* redLightNode1 = rootNode->createChildSceneNode();
476                redLightNode1->setPosition(0.05,2.361,-1.07);
477                redLightNode1->attachObject(redLight1);
478
479                Light* greenLight1 = mSceneMgr->createLight("GreenLight1");
480                greenLight1->setType(Light::LT_POINT);
481                greenLight1->setCastShadows(false);
482        greenLight1->setDiffuseColour(ColourValue(0.362,0.783, 0.685));
483                greenLight1->setPowerScale(2.0);
484                greenLight1->setAttenuation(20, 0, 0, 3);
485                //greenLight1->setPowerScale(1.0);
486                SceneNode* greenLightNode1 = rootNode->createChildSceneNode();
487                greenLightNode1->setPosition(1.312,1.313,0);
488                greenLightNode1->attachObject(greenLight1);
489
490                Light* mainBlueLight = mSceneMgr->createLight("MainBlueLight");
491                mainBlueLight->setType(Light::LT_SPOTLIGHT);
492                mainBlueLight->setCastShadows(true);
493        mainBlueLight->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
494                mainBlueLight->setPowerScale(5.0);
495                //mainBlueLight->setPowerScale(2.0);
496                mainBlueLight->setSpotlightRange(Degree(0),Degree(160));
497                mainBlueLight->setAttenuation(2.5, 0, 0, 3);
498                //mainBlueLight->setAttenuation(20, 0, 0, 1);
499                SceneNode* mainBlueLightNode = rootNode->createChildSceneNode();
500                mainBlueLightNode->setPosition(-0.546,2.095,1.035);
501                //mainBlueLightNode->rotate(Vector3::UNIT_X, Degree(161.396));
502                //mainBlueLightNode->rotate(Vector3::UNIT_Y, Degree(53.955));
503                //mainBlueLightNode->rotate(Vector3::UNIT_Z, Degree(-145.065));
504                mainBlueLight->setDirection(-1.5,-2.0,1.0);
505                mainBlueLightNode->attachObject(mainBlueLight);
506/*
507                Light* blueLight1 = mSceneMgr->createLight("BlueLight1");
508                blueLight1->setType(Light::LT_SPOTLIGHT);
509                blueLight1->setCastShadows(false);
510        blueLight1->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
511                blueLight1->setPowerScale(0.7);
512                blueLight1->setSpotlightRange(Degree(20),Degree(90));
513                SceneNode* blueLightNode = rootNode->createChildSceneNode();
514                blueLightNode->setPosition(-0.9,2.095,0.185);
515                //blueLightNode->rotate(Vector3::UNIT_X, Degree(148.785));
516                //blueLightNode->rotate(Vector3::UNIT_Y, Degree(39.001));
517                //blueLightNode->rotate(Vector3::UNIT_Z, Degree(-154.304));
518                blueLight1->setDirection(-1.5,-2.0,1.0);
519                blueLightNode->attachObject(blueLight1);
520
521                Light* blueLight2 = mSceneMgr->createLight("BlueLight2");
522                blueLight2->setType(Light::LT_SPOTLIGHT);
523                blueLight2->setCastShadows(false);
524        blueLight2->setDiffuseColour(ColourValue(0.395,0.766, 1.0));
525                blueLight2->setPowerScale(0.7);
526                blueLight2->setSpotlightRange(Degree(20),Degree(90));
527                SceneNode* blueLightNode2 = rootNode->createChildSceneNode();
528                blueLightNode2->setPosition(0.091,2.095,1.556);
529                //blueLightNode2->rotate(Vector3::UNIT_X, Degree(-112.941));
530                //blueLightNode2->rotate(Vector3::UNIT_Y, Degree(68.432));
531                //blueLightNode2->rotate(Vector3::UNIT_Z, Degree(-66.441));
532                blueLight2->setDirection(-1.5,-2.0,1.0);
533                blueLightNode2->attachObject(blueLight2); */
534   }
535
536   void createPlane(Ogre::String _name, Ogre::String _material, Ogre::Vector3 _pos, Ogre::Vector2 _size, Ogre::Vector2 _subdivisions = Ogre::Vector2(1,1)) {
537               
538           Plane _plane;
539        _plane.normal = Vector3::UNIT_Y;
540        _plane.d = 0;
541
542
543        MeshManager::getSingleton().createPlane(_name + ".plane",
544            ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME,
545            _plane,_size.x,_size.y,1,1,true,1,_subdivisions.x,_subdivisions.y,Vector3::UNIT_Z);
546       
547                Entity *_entity = mSceneMgr->createEntity(_name + ".entity", _name + ".plane");
548        _entity->setMaterialName(_material);
549
550                SceneNode* _node = mSceneMgr->getRootSceneNode()->createChildSceneNode(_name + ".node");
551                _node->attachObject(_entity);
552                _node->setPosition(_pos);
553        }
554
555
556
557        void createFrameListener(void)
558    {
559                // This is where we instantiate our own frame listener
560                mFrameListener= new RaytraceDemoListener(mWindow,
561                                                                                        mCamera,
562                                                                                        objectNode
563                                                                                        );
564                mFrameListener->setPriority(1);
565                OgreIlluminationManager::getSingleton().setPriority(10);
566                capture->setPriority(6);
567        mRoot->addFrameListener(capture);
568        mRoot->addFrameListener(&OgreIlluminationManager::getSingleton());
569                mRoot->addFrameListener(mFrameListener);
570               
571    }
572
573};
574
575
Note: See TracBrowser for help on using the repository browser.