[3255] | 1 |
|
---|
| 2 |
|
---|
| 3 |
|
---|
| 4 | /*
|
---|
| 5 | -----------------------------------------------------------------------------
|
---|
| 6 | This source file is part of OGRE
|
---|
| 7 | (Object-oriented Graphics Rendering Engine)
|
---|
| 8 | For the latest info, see http://www.ogre3d.org/
|
---|
| 9 |
|
---|
| 10 | Copyright (c) 2000-2005 The OGRE Team
|
---|
| 11 | Also see acknowledgements in Readme.html
|
---|
| 12 |
|
---|
| 13 | You may use this sample code for anything you like, it is not covered by the
|
---|
| 14 | LGPL like the rest of the engine.
|
---|
| 15 | -----------------------------------------------------------------------------
|
---|
| 16 | */
|
---|
| 17 |
|
---|
| 18 | /**
|
---|
| 19 | \file
|
---|
| 20 | Lighting.h
|
---|
| 21 | \brief
|
---|
| 22 | Shows lighting support in OGRE. Also demonstrates the use of billboards
|
---|
| 23 | and controllers for automatic time-relative behaviour.
|
---|
| 24 | */
|
---|
| 25 |
|
---|
| 26 |
|
---|
| 27 | #include "ExampleApplication.h"
|
---|
| 28 | #include "OgreIlluminationManager.h"
|
---|
| 29 | #include "SpriteParticleRenderer.h"
|
---|
| 30 | #include "FrameCapture.h"
|
---|
| 31 | #include "OgreCausticCubeMapRenderingRun.h"
|
---|
| 32 |
|
---|
| 33 | float worldSizeVar = 0.002;
|
---|
| 34 | float refIndex = 0.8;
|
---|
| 35 | int scene = 2;
|
---|
| 36 | FrameCapture* capture;
|
---|
| 37 |
|
---|
| 38 | bool multiplebounce = true;
|
---|
| 39 | bool useCauInt = true;
|
---|
| 40 |
|
---|
| 41 | int currentMaterial = 0;
|
---|
| 42 | int currentObject = 1;
|
---|
| 43 | String objectNames[] = {String("sphere.mesh"),
|
---|
| 44 | String("teapot.mesh"),
|
---|
| 45 | String("colorcube.mesh"),
|
---|
| 46 | String("head.mesh")};
|
---|
| 47 |
|
---|
| 48 | float objectscales[] = {0.015,1.7,1,0.1};
|
---|
| 49 | float scenescales[] = {0.3,1, 2.7};
|
---|
| 50 |
|
---|
| 51 | String 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 |
|
---|
| 60 | String 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
|
---|
| 69 | class RaytraceDemoListener : public ExampleFrameListener
|
---|
| 70 | {
|
---|
| 71 | protected:
|
---|
| 72 | unsigned long framecount;
|
---|
| 73 | SceneNode* objectNode;
|
---|
| 74 | Entity *object;
|
---|
| 75 |
|
---|
| 76 | public:
|
---|
| 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 */
|
---|
| 368 | class RaytraceDemoApplication : public ExampleApplication
|
---|
| 369 | {
|
---|
| 370 |
|
---|
| 371 | public:
|
---|
| 372 |
|
---|
| 373 |
|
---|
| 374 | protected:
|
---|
| 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 |
|
---|