[1] | 1 | /* |
---|
| 2 | ----------------------------------------------------------------------------- |
---|
| 3 | This source file is part of OGRE |
---|
| 4 | (Object-oriented Graphics Rendering Engine) |
---|
| 5 | For the latest info, see http://www.ogre3d.org/ |
---|
| 6 | |
---|
| 7 | Copyright (c) 2000-2006 Torus Knot Software Ltd |
---|
| 8 | Also see acknowledgements in Readme.html |
---|
| 9 | |
---|
| 10 | You may use this sample code for anything you like, it is not covered by the |
---|
| 11 | LGPL like the rest of the engine. |
---|
| 12 | ----------------------------------------------------------------------------- |
---|
| 13 | */ |
---|
| 14 | |
---|
| 15 | #include "OceanDemo.h" |
---|
| 16 | #include "Ogre.h" |
---|
| 17 | |
---|
| 18 | #include <cstdlib> |
---|
| 19 | |
---|
| 20 | |
---|
| 21 | /********************************************************************** |
---|
| 22 | OS X Specific Resource Location Finding |
---|
| 23 | **********************************************************************/ |
---|
| 24 | #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE |
---|
| 25 | |
---|
| 26 | Ogre::String bundlePath() |
---|
| 27 | { |
---|
| 28 | char path[1024]; |
---|
| 29 | CFBundleRef mainBundle = CFBundleGetMainBundle(); |
---|
| 30 | assert( mainBundle ); |
---|
| 31 | |
---|
| 32 | CFURLRef mainBundleURL = CFBundleCopyBundleURL( mainBundle); |
---|
| 33 | assert( mainBundleURL); |
---|
| 34 | |
---|
| 35 | CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle); |
---|
| 36 | assert( cfStringRef); |
---|
| 37 | |
---|
| 38 | CFStringGetCString( cfStringRef, path, 1024, kCFStringEncodingASCII); |
---|
| 39 | |
---|
| 40 | CFRelease( mainBundleURL); |
---|
| 41 | CFRelease( cfStringRef); |
---|
| 42 | |
---|
| 43 | return Ogre::String( path); |
---|
| 44 | } |
---|
| 45 | |
---|
| 46 | #endif |
---|
| 47 | |
---|
| 48 | /********************************************************************** |
---|
| 49 | Static declarations |
---|
| 50 | **********************************************************************/ |
---|
| 51 | // Lights |
---|
| 52 | #define NUM_LIGHTS 1 |
---|
| 53 | |
---|
| 54 | // the light |
---|
| 55 | Ogre::Light* mLights[NUM_LIGHTS]; |
---|
| 56 | // billboards for lights |
---|
| 57 | Ogre::BillboardSet* mLightFlareSets[NUM_LIGHTS]; |
---|
| 58 | Ogre::Billboard* mLightFlares[NUM_LIGHTS]; |
---|
| 59 | // Positions for lights |
---|
| 60 | Ogre::Vector3 mLightPositions[NUM_LIGHTS] = |
---|
| 61 | { |
---|
| 62 | Ogre::Vector3(00, 400, 00) |
---|
| 63 | }; |
---|
| 64 | // Base orientations of the lights |
---|
| 65 | Ogre::Real mLightRotationAngles[NUM_LIGHTS] = { 35 }; |
---|
| 66 | Ogre::Vector3 mLightRotationAxes[NUM_LIGHTS] = { |
---|
| 67 | Ogre::Vector3::UNIT_X |
---|
| 68 | }; |
---|
| 69 | // Rotation speed for lights, degrees per second |
---|
| 70 | Ogre::Real mLightSpeeds[NUM_LIGHTS] = { 30}; |
---|
| 71 | |
---|
| 72 | // Colours for the lights |
---|
| 73 | Ogre::ColourValue mDiffuseLightColours[NUM_LIGHTS] = |
---|
| 74 | { |
---|
| 75 | Ogre::ColourValue(0.6, 0.6, 0.6) |
---|
| 76 | }; |
---|
| 77 | |
---|
| 78 | Ogre::ColourValue mSpecularLightColours[NUM_LIGHTS] = |
---|
| 79 | { |
---|
| 80 | Ogre::ColourValue(0.5, 0.5, 0.5) |
---|
| 81 | }; |
---|
| 82 | |
---|
| 83 | // Which lights are enabled |
---|
| 84 | bool mLightState[NUM_LIGHTS] = |
---|
| 85 | { |
---|
| 86 | true |
---|
| 87 | }; |
---|
| 88 | |
---|
| 89 | // the light nodes |
---|
| 90 | Ogre::SceneNode* mLightNodes[NUM_LIGHTS]; |
---|
| 91 | // the light node pivots |
---|
| 92 | Ogre::SceneNode* mLightPivots[NUM_LIGHTS]; |
---|
| 93 | |
---|
| 94 | #define UVECTOR2(x, y) UVector2(cegui_reldim(x), cegui_reldim(y)) |
---|
| 95 | #define TEXTWIDGET_SIZE UVECTOR2(0.19, 0.06) |
---|
| 96 | #define NUMBERWIDGET_SIZE UVECTOR2(0.065, 0.06) |
---|
| 97 | #define SCROLLWIDGET_SIZE UVECTOR2(0.21, 0.02) |
---|
| 98 | |
---|
| 99 | #define TEXTWIDGET_XPOS 0.01 |
---|
| 100 | #define NUMBERWIDGET_XPOS 0.37 |
---|
| 101 | #define SCROLLWIDGET_XPOS 0.50 |
---|
| 102 | |
---|
| 103 | #define TEXTWIDGET_YADJUST (-0.05f) |
---|
| 104 | #define WIDGET_YSTART 0.2f |
---|
| 105 | #define WIDGET_YOFFSET 0.15f |
---|
| 106 | |
---|
| 107 | /************************************************************************* |
---|
| 108 | sub-class for ListboxTextItem that auto-sets the selection brush |
---|
| 109 | image. |
---|
| 110 | *************************************************************************/ |
---|
| 111 | class MyListItem : public CEGUI::ListboxTextItem |
---|
| 112 | { |
---|
| 113 | public: |
---|
| 114 | MyListItem(const CEGUI::String& text, CEGUI::uint id) : CEGUI::ListboxTextItem(text, id) |
---|
| 115 | { |
---|
| 116 | setSelectionBrushImage("TaharezLook", "MultiListSelectionBrush"); |
---|
| 117 | } |
---|
| 118 | }; |
---|
| 119 | |
---|
| 120 | |
---|
| 121 | |
---|
| 122 | /********************************************************************* |
---|
| 123 | Main Program Entry Point |
---|
| 124 | ***********************************************************************/ |
---|
| 125 | #ifdef __cplusplus |
---|
| 126 | extern "C" { |
---|
| 127 | #endif |
---|
| 128 | |
---|
| 129 | #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 |
---|
| 130 | #define WIN32_LEAN_AND_MEAN |
---|
| 131 | #include "windows.h" |
---|
| 132 | |
---|
| 133 | INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT ) |
---|
| 134 | #else |
---|
| 135 | int main(int argc, char *argv[]) |
---|
| 136 | #endif |
---|
| 137 | { |
---|
| 138 | // Create application object |
---|
| 139 | OceanDemo app; |
---|
| 140 | |
---|
| 141 | try { |
---|
| 142 | app.go(); |
---|
| 143 | |
---|
| 144 | } catch( Ogre::Exception& e ) { |
---|
| 145 | #if OGRE_PLATFORM == PLATFORM_WIN32 |
---|
| 146 | MessageBox( NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL); |
---|
| 147 | #else |
---|
| 148 | std::cerr << "An exception has occured: " << |
---|
| 149 | e.getFullDescription().c_str() << std::endl; |
---|
| 150 | #endif |
---|
| 151 | } |
---|
| 152 | |
---|
| 153 | return 0; |
---|
| 154 | } |
---|
| 155 | |
---|
| 156 | #ifdef __cplusplus |
---|
| 157 | } |
---|
| 158 | #endif |
---|
| 159 | |
---|
| 160 | /************************************************************************* |
---|
| 161 | OceanDemo Methods |
---|
| 162 | *************************************************************************/ |
---|
| 163 | OceanDemo::~OceanDemo() |
---|
| 164 | { |
---|
| 165 | delete mGUISystem; |
---|
| 166 | delete mGUIRenderer; |
---|
| 167 | delete mFrameListener; |
---|
| 168 | |
---|
| 169 | // get rid of the shared pointers before shutting down ogre or exceptions occure |
---|
| 170 | mActiveFragmentProgram.setNull(); |
---|
| 171 | mActiveFragmentParameters.setNull(); |
---|
| 172 | mActiveVertexProgram.setNull(); |
---|
| 173 | mActiveVertexParameters.setNull(); |
---|
| 174 | mActiveMaterial.setNull(); |
---|
| 175 | |
---|
| 176 | delete mRoot; |
---|
| 177 | } |
---|
| 178 | |
---|
| 179 | //-------------------------------------------------------------------------- |
---|
| 180 | void OceanDemo::go(void) |
---|
| 181 | { |
---|
| 182 | if (!setup()) |
---|
| 183 | return; |
---|
| 184 | |
---|
| 185 | mRoot->startRendering(); |
---|
| 186 | } |
---|
| 187 | |
---|
| 188 | //-------------------------------------------------------------------------- |
---|
| 189 | bool OceanDemo::setup(void) |
---|
| 190 | { |
---|
| 191 | bool setupCompleted = false; |
---|
| 192 | |
---|
| 193 | #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE |
---|
| 194 | Ogre::String mResourcePath; |
---|
| 195 | mResourcePath = bundlePath() + "/Contents/Resources/"; |
---|
| 196 | mRoot = new Ogre::Root(mResourcePath + "plugins.cfg", |
---|
| 197 | mResourcePath + "ogre.cfg", mResourcePath + "Ogre.log"); |
---|
| 198 | #else |
---|
| 199 | |
---|
| 200 | mRoot = new Ogre::Root(); |
---|
| 201 | |
---|
| 202 | #endif |
---|
| 203 | |
---|
| 204 | setupResources(); |
---|
| 205 | |
---|
| 206 | if (configure()) |
---|
| 207 | { |
---|
| 208 | chooseSceneManager(); |
---|
| 209 | createCamera(); |
---|
| 210 | createViewports(); |
---|
| 211 | |
---|
| 212 | // Set default mipmap level (NB some APIs ignore this) |
---|
| 213 | Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5); |
---|
| 214 | loadResources(); |
---|
| 215 | |
---|
| 216 | |
---|
| 217 | if (setupGUI()) |
---|
| 218 | { |
---|
| 219 | // Create the scene |
---|
| 220 | createScene(); |
---|
| 221 | |
---|
| 222 | createFrameListener(); |
---|
| 223 | |
---|
| 224 | // load some GUI stuff for demo. |
---|
| 225 | loadAllMaterialControlFiles(mMaterialControlsContainer); |
---|
| 226 | initDemoEventWiring(); |
---|
| 227 | initComboBoxes(); |
---|
| 228 | setupCompleted = true; |
---|
| 229 | } |
---|
| 230 | } |
---|
| 231 | |
---|
| 232 | return setupCompleted; |
---|
| 233 | } |
---|
| 234 | |
---|
| 235 | //-------------------------------------------------------------------------- |
---|
| 236 | bool OceanDemo::configure(void) |
---|
| 237 | { |
---|
| 238 | // Show the configuration dialog and initialise the system |
---|
| 239 | // You can skip this and use root.restoreConfig() to load configuration |
---|
| 240 | // settings if you were sure there are valid ones saved in ogre.cfg |
---|
| 241 | if(mRoot->showConfigDialog()) |
---|
| 242 | { |
---|
| 243 | // If returned true, user clicked OK so initialise |
---|
| 244 | // Here we choose to let the system create a default rendering window by passing 'true' |
---|
| 245 | mWindow = mRoot->initialise(true); |
---|
| 246 | return true; |
---|
| 247 | } |
---|
| 248 | else |
---|
| 249 | { |
---|
| 250 | return false; |
---|
| 251 | } |
---|
| 252 | } |
---|
| 253 | |
---|
| 254 | //-------------------------------------------------------------------------- |
---|
| 255 | void OceanDemo::chooseSceneManager(void) |
---|
| 256 | { |
---|
| 257 | // Get the SceneManager, in this case a generic one |
---|
| 258 | mSceneMgr = mRoot->createSceneManager(Ogre::ST_GENERIC, "ExampleSMInstance"); |
---|
| 259 | } |
---|
| 260 | |
---|
| 261 | //-------------------------------------------------------------------------- |
---|
| 262 | void OceanDemo::createCamera(void) |
---|
| 263 | { |
---|
| 264 | // Create the camera |
---|
| 265 | mCamera = mSceneMgr->createCamera("PlayerCam"); |
---|
| 266 | |
---|
| 267 | // Position it at 500 in Z direction |
---|
| 268 | mCamera->setPosition(Ogre::Vector3(0,0,0)); |
---|
| 269 | // Look back along -Z |
---|
| 270 | mCamera->lookAt(Ogre::Vector3(0,0,-300)); |
---|
| 271 | mCamera->setNearClipDistance(1); |
---|
| 272 | |
---|
| 273 | } |
---|
| 274 | |
---|
| 275 | //-------------------------------------------------------------------------- |
---|
| 276 | void OceanDemo::createViewports(void) |
---|
| 277 | { |
---|
| 278 | // Create one viewport, entire window |
---|
| 279 | Ogre::Viewport* vp = mWindow->addViewport(mCamera); |
---|
| 280 | vp->setBackgroundColour(Ogre::ColourValue(0,0,0)); |
---|
| 281 | |
---|
| 282 | // Alter the camera aspect ratio to match the viewport |
---|
| 283 | mCamera->setAspectRatio( |
---|
| 284 | Ogre::Real(vp->getActualWidth()) / Ogre::Real(vp->getActualHeight())); |
---|
| 285 | } |
---|
| 286 | |
---|
| 287 | //-------------------------------------------------------------------------- |
---|
| 288 | void OceanDemo::setupResources(void) |
---|
| 289 | { |
---|
| 290 | // Load resource paths from config file |
---|
| 291 | Ogre::ConfigFile cf; |
---|
| 292 | |
---|
| 293 | #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE |
---|
| 294 | Ogre::String mResourcePath; |
---|
| 295 | mResourcePath = bundlePath() + "/Contents/Resources/"; |
---|
| 296 | cf.load(mResourcePath + "resources.cfg"); |
---|
| 297 | #else |
---|
| 298 | cf.load("resources.cfg"); |
---|
| 299 | #endif |
---|
| 300 | |
---|
| 301 | // Go through all sections & settings in the file |
---|
| 302 | Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator(); |
---|
| 303 | |
---|
| 304 | Ogre::String secName, typeName, archName; |
---|
| 305 | while (seci.hasMoreElements()) |
---|
| 306 | { |
---|
| 307 | secName = seci.peekNextKey(); |
---|
| 308 | Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext(); |
---|
| 309 | Ogre::ConfigFile::SettingsMultiMap::iterator i; |
---|
| 310 | for (i = settings->begin(); i != settings->end(); ++i) |
---|
| 311 | { |
---|
| 312 | typeName = i->first; |
---|
| 313 | archName = i->second; |
---|
| 314 | #if OGRE_PLATFORM == OGRE_PLATFORM_APPLE |
---|
| 315 | // OS X does not set the working directory relative to the app, |
---|
| 316 | // In order to make things portable on OS X we need to provide |
---|
| 317 | // the loading with it's own bundle path location |
---|
| 318 | Ogre::ResourceGroupManager::getSingleton().addResourceLocation( |
---|
| 319 | Ogre::String(bundlePath() + "/" + archName), typeName, secName); |
---|
| 320 | #else |
---|
| 321 | Ogre::ResourceGroupManager::getSingleton().addResourceLocation( |
---|
| 322 | archName, typeName, secName); |
---|
| 323 | #endif |
---|
| 324 | } |
---|
| 325 | } |
---|
| 326 | |
---|
| 327 | Ogre::LogManager::getSingleton().logMessage( "Resource directories setup" ); |
---|
| 328 | |
---|
| 329 | } |
---|
| 330 | |
---|
| 331 | //----------------------------------------------------------------------------------- |
---|
| 332 | void OceanDemo::loadResources(void) |
---|
| 333 | { |
---|
| 334 | // Initialise, parse scripts etc |
---|
| 335 | Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups(); |
---|
| 336 | |
---|
| 337 | } |
---|
| 338 | |
---|
| 339 | //-------------------------------------------------------------------------- |
---|
| 340 | bool OceanDemo::setupGUI(void) |
---|
| 341 | { |
---|
| 342 | bool setupGUICompleted = false; |
---|
| 343 | // setup GUI system |
---|
| 344 | try |
---|
| 345 | { |
---|
| 346 | mGUIRenderer = new CEGUI::OgreCEGUIRenderer(mWindow, Ogre::RENDER_QUEUE_OVERLAY, false, 0, mSceneMgr); |
---|
| 347 | // load scheme and set up defaults |
---|
| 348 | |
---|
| 349 | mGUISystem = new CEGUI::System(mGUIRenderer, 0, 0, 0, (CEGUI::utf8*)"OceanDemoCegui.config"); |
---|
| 350 | CEGUI::System::getSingleton().setDefaultMouseCursor("TaharezLook", "MouseArrow"); |
---|
| 351 | setupGUICompleted = true; |
---|
| 352 | } |
---|
| 353 | catch(...) |
---|
| 354 | { |
---|
| 355 | |
---|
| 356 | } |
---|
| 357 | |
---|
| 358 | return setupGUICompleted; |
---|
| 359 | } |
---|
| 360 | //-------------------------------------------------------------------------- |
---|
| 361 | void OceanDemo::createScene(void) |
---|
| 362 | { |
---|
| 363 | // Set ambient light |
---|
| 364 | mSceneMgr->setAmbientLight(Ogre::ColourValue(0.3, 0.3, 0.3)); |
---|
| 365 | mSceneMgr->setSkyBox(true, "SkyBox", 1000); |
---|
| 366 | |
---|
| 367 | mMainNode = mSceneMgr->getRootSceneNode()->createChildSceneNode(); |
---|
| 368 | |
---|
| 369 | |
---|
| 370 | for (unsigned int i = 0; i < NUM_LIGHTS; ++i) |
---|
| 371 | { |
---|
| 372 | mLightPivots[i] = mSceneMgr->getRootSceneNode()->createChildSceneNode(); |
---|
| 373 | mLightPivots[i]->rotate(mLightRotationAxes[i], Ogre::Angle(mLightRotationAngles[i])); |
---|
| 374 | // Create a light, use default parameters |
---|
| 375 | mLights[i] = mSceneMgr->createLight("Light" + Ogre::StringConverter::toString(i)); |
---|
| 376 | mLights[i]->setPosition(mLightPositions[i]); |
---|
| 377 | mLights[i]->setDiffuseColour(mDiffuseLightColours[i]); |
---|
| 378 | mLights[i]->setSpecularColour(mSpecularLightColours[i]); |
---|
| 379 | mLights[i]->setVisible(mLightState[i]); |
---|
| 380 | //mLights[i]->setAttenuation(400, 0.1 , 1 , 0); |
---|
| 381 | // Attach light |
---|
| 382 | mLightPivots[i]->attachObject(mLights[i]); |
---|
| 383 | // Create billboard for light |
---|
| 384 | mLightFlareSets[i] = mSceneMgr->createBillboardSet("Flare" + Ogre::StringConverter::toString(i)); |
---|
| 385 | mLightFlareSets[i]->setMaterialName("LightFlare"); |
---|
| 386 | mLightPivots[i]->attachObject(mLightFlareSets[i]); |
---|
| 387 | mLightFlares[i] = mLightFlareSets[i]->createBillboard(mLightPositions[i]); |
---|
| 388 | mLightFlares[i]->setColour(mDiffuseLightColours[i]); |
---|
| 389 | mLightFlareSets[i]->setVisible(mLightState[i]); |
---|
| 390 | } |
---|
| 391 | |
---|
| 392 | // move the camera a bit right and make it look at the knot |
---|
| 393 | mCamera->moveRelative(Ogre::Vector3(50, 0, 100)); |
---|
| 394 | mCamera->lookAt(0, 0, 0); |
---|
| 395 | |
---|
| 396 | // Define a plane mesh that will be used for the ocean surface |
---|
| 397 | Ogre::Plane oceanSurface; |
---|
| 398 | oceanSurface.normal = Ogre::Vector3::UNIT_Y; |
---|
| 399 | oceanSurface.d = 20; |
---|
| 400 | Ogre::MeshManager::getSingleton().createPlane("OceanSurface", |
---|
| 401 | Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, |
---|
| 402 | oceanSurface, |
---|
| 403 | 1000, 1000, 50, 50, true, 1, 1, 1, Ogre::Vector3::UNIT_Z); |
---|
| 404 | |
---|
| 405 | mOceanSurfaceEnt = mSceneMgr->createEntity( "OceanSurface", "OceanSurface" ); |
---|
| 406 | mSceneMgr->getRootSceneNode()->createChildSceneNode()->attachObject(mOceanSurfaceEnt); |
---|
| 407 | |
---|
| 408 | } |
---|
| 409 | |
---|
| 410 | |
---|
| 411 | //-------------------------------------------------------------------------- |
---|
| 412 | void OceanDemo::initComboBoxes(void) |
---|
| 413 | { |
---|
| 414 | using namespace CEGUI; |
---|
| 415 | |
---|
| 416 | |
---|
| 417 | Combobox* cbobox = (Combobox*)WindowManager::getSingleton().getWindow("ShaderCombos"); |
---|
| 418 | |
---|
| 419 | for(size_t idx = 0; idx < mMaterialControlsContainer.size(); ++idx ) |
---|
| 420 | { |
---|
| 421 | cbobox->addItem(new MyListItem( mMaterialControlsContainer[idx].getDisplayName().c_str(), static_cast<CEGUI::uint>(idx))); |
---|
| 422 | } |
---|
| 423 | |
---|
| 424 | // make first item visible |
---|
| 425 | if (cbobox->getItemCount() > 0) |
---|
| 426 | cbobox->setItemSelectState((size_t)0, true); |
---|
| 427 | |
---|
| 428 | Editbox* eb; |
---|
| 429 | // set text in combobox |
---|
| 430 | if (!mMaterialControlsContainer.empty()) |
---|
| 431 | { |
---|
| 432 | eb = (Editbox*)WindowManager::getSingleton().getWindow(cbobox->getName() + "__auto_editbox__"); |
---|
| 433 | eb->setText(mMaterialControlsContainer[0].getDisplayName().c_str()); |
---|
| 434 | handleShaderComboChanged(CEGUI::WindowEventArgs(cbobox)); |
---|
| 435 | } |
---|
| 436 | |
---|
| 437 | cbobox = (Combobox*)WindowManager::getSingleton().getWindow("ModelCombos"); |
---|
| 438 | Ogre::StringVectorPtr meshStringVector = Ogre::ResourceGroupManager::getSingleton().findResourceNames( Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "*.mesh" ); |
---|
| 439 | std::vector<Ogre::String>::iterator meshFileNameIterator = meshStringVector->begin(); |
---|
| 440 | |
---|
| 441 | while ( meshFileNameIterator != meshStringVector->end() ) |
---|
| 442 | { |
---|
| 443 | cbobox->addItem(new MyListItem( (*meshFileNameIterator).c_str(), 0 )); |
---|
| 444 | ++meshFileNameIterator; |
---|
| 445 | } |
---|
| 446 | |
---|
| 447 | // make first item visible |
---|
| 448 | //cbobox->setItemSelectState((CEGUI::uint)0, true); |
---|
| 449 | // eb = (Editbox*)WindowManager::getSingleton().getWindow(cbobox->getName() + "__auto_editbox__"); |
---|
| 450 | // if (meshStringVector->begin() != meshStringVector->end()) |
---|
| 451 | // { |
---|
| 452 | // eb->setText((*meshStringVector->begin()).c_str()); |
---|
| 453 | // handleModelComboChanged(CEGUI::WindowEventArgs(cbobox)); |
---|
| 454 | // } |
---|
| 455 | |
---|
| 456 | } |
---|
| 457 | |
---|
| 458 | |
---|
| 459 | //-------------------------------------------------------------------------- |
---|
| 460 | void OceanDemo::initDemoEventWiring(void) |
---|
| 461 | { |
---|
| 462 | using namespace CEGUI; |
---|
| 463 | |
---|
| 464 | WindowManager::getSingleton().getWindow("ExitDemoBtn")-> |
---|
| 465 | subscribeEvent(PushButton::EventClicked, CEGUI::Event::Subscriber(&OceanDemo::handleQuit, this)); |
---|
| 466 | |
---|
| 467 | WindowManager::getSingleton().getWindow("ModelCombos")-> |
---|
| 468 | subscribeEvent(Combobox::EventListSelectionAccepted, CEGUI::Event::Subscriber(&OceanDemo::handleModelComboChanged, this)); |
---|
| 469 | |
---|
| 470 | WindowManager::getSingleton().getWindow("ShaderCombos")-> |
---|
| 471 | subscribeEvent(Combobox::EventListSelectionAccepted, CEGUI::Event::Subscriber(&OceanDemo::handleShaderComboChanged, this)); |
---|
| 472 | |
---|
| 473 | Window* wndw = WindowManager::getSingleton().getWindow("root"); |
---|
| 474 | |
---|
| 475 | wndw->subscribeEvent(Window::EventMouseMove, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handleMouseMove, mFrameListener)); |
---|
| 476 | |
---|
| 477 | wndw->subscribeEvent(Window::EventMouseButtonUp, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handleMouseButtonUp, mFrameListener)); |
---|
| 478 | |
---|
| 479 | wndw->subscribeEvent(Window::EventMouseButtonDown, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handleMouseButtonDown, mFrameListener)); |
---|
| 480 | |
---|
| 481 | wndw->subscribeEvent(Window::EventMouseWheel, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handleMouseWheelEvent, mFrameListener)); |
---|
| 482 | wndw->subscribeEvent(Window::EventKeyDown, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handleKeyDownEvent, mFrameListener )); |
---|
| 483 | wndw->subscribeEvent(Window::EventKeyUp, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handleKeyUpEvent, mFrameListener )); |
---|
| 484 | |
---|
| 485 | wndw = WindowManager::getSingleton().getWindow("ModelSpinCB"); |
---|
| 486 | wndw->subscribeEvent(Checkbox::EventCheckStateChanged, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handelModelSpinChange, mFrameListener )); |
---|
| 487 | |
---|
| 488 | wndw = WindowManager::getSingleton().getWindow("LightSpinCB"); |
---|
| 489 | wndw->subscribeEvent(Checkbox::EventCheckStateChanged, CEGUI::Event::Subscriber(&OceanDemo_FrameListener::handelLightSpinChange, mFrameListener )); |
---|
| 490 | |
---|
| 491 | wndw = WindowManager::getSingleton().getWindow("CameraRBtn"); |
---|
| 492 | wndw->subscribeEvent(RadioButton::EventSelectStateChanged, CEGUI::Event::Subscriber(&OceanDemo::handleMovementTypeChange, this )); |
---|
| 493 | |
---|
| 494 | wndw = WindowManager::getSingleton().getWindow("ModelRBtn"); |
---|
| 495 | wndw->subscribeEvent(RadioButton::EventSelectStateChanged, CEGUI::Event::Subscriber(&OceanDemo::handleMovementTypeChange, this )); |
---|
| 496 | |
---|
| 497 | mVertScroll = (Scrollbar*)WindowManager::getSingleton().getWindow("VerticalScroll"); |
---|
| 498 | mVertScroll->subscribeEvent(Scrollbar::EventScrollPositionChanged, CEGUI::Event::Subscriber(&OceanDemo::handleScrollControlsWindow, this )); |
---|
| 499 | |
---|
| 500 | } |
---|
| 501 | |
---|
| 502 | |
---|
| 503 | //-------------------------------------------------------------------------- |
---|
| 504 | void OceanDemo::doErrorBox(const char* text) |
---|
| 505 | { |
---|
| 506 | using namespace CEGUI; |
---|
| 507 | |
---|
| 508 | WindowManager& winMgr = WindowManager::getSingleton(); |
---|
| 509 | Window* root = winMgr.getWindow("root_wnd"); |
---|
| 510 | |
---|
| 511 | FrameWindow* errbox; |
---|
| 512 | |
---|
| 513 | try |
---|
| 514 | { |
---|
| 515 | errbox = (FrameWindow*)winMgr.getWindow("ErrorBox"); |
---|
| 516 | } |
---|
| 517 | catch(UnknownObjectException x) |
---|
| 518 | { |
---|
| 519 | // create frame window for box |
---|
| 520 | FrameWindow* fwnd = (FrameWindow*)winMgr.createWindow("TaharezLook/FrameWindow", "ErrorBox"); |
---|
| 521 | root->addChildWindow(fwnd); |
---|
| 522 | fwnd->setPosition(UVECTOR2(0.25, 0.25f)); |
---|
| 523 | fwnd->setMaxSize(UVECTOR2(1.0f, 1.0f)); |
---|
| 524 | fwnd->setSize(UVECTOR2(0.5f, 0.5f)); |
---|
| 525 | fwnd->setText("CEGUI Demo - Error!"); |
---|
| 526 | fwnd->setDragMovingEnabled(false); |
---|
| 527 | fwnd->setSizingEnabled(false); |
---|
| 528 | fwnd->setAlwaysOnTop(true); |
---|
| 529 | fwnd->setCloseButtonEnabled(false); |
---|
| 530 | |
---|
| 531 | // create error text message |
---|
| 532 | Window* wnd = winMgr.createWindow("TaharezLook/StaticText", "ErrorBox/Message"); |
---|
| 533 | fwnd->addChildWindow(wnd); |
---|
| 534 | wnd->setPosition(UVECTOR2(0.1f, 0.1f)); |
---|
| 535 | wnd->setSize(UVECTOR2(0.8f, 0.5f)); |
---|
| 536 | wnd->setProperty("VertFormatting", "VertCentred"); |
---|
| 537 | wnd->setProperty("HorzFormatting", "HorzCentred"); |
---|
| 538 | wnd->setProperty("BackgroundEnabled", "false"); |
---|
| 539 | wnd->setProperty("FrameEnabled", "false"); |
---|
| 540 | |
---|
| 541 | // create ok button |
---|
| 542 | wnd = (PushButton*)winMgr.createWindow("TaharezLook/Button", "ErrorBox/OkButton"); |
---|
| 543 | fwnd->addChildWindow(wnd); |
---|
| 544 | wnd->setPosition(UVECTOR2(0.3f, 0.80f)); |
---|
| 545 | wnd->setSize(UVECTOR2(0.4f, 0.1f)); |
---|
| 546 | wnd->setText("Okay!"); |
---|
| 547 | |
---|
| 548 | // subscribe event |
---|
| 549 | wnd->subscribeEvent(PushButton::EventClicked, CEGUI::Event::Subscriber(&OceanDemo::handleErrorBox, this )); |
---|
| 550 | |
---|
| 551 | errbox = fwnd; |
---|
| 552 | } |
---|
| 553 | |
---|
| 554 | errbox->getChild("ErrorBox/Message")->setText(text); |
---|
| 555 | errbox->show(); |
---|
| 556 | errbox->activate(); |
---|
| 557 | } |
---|
| 558 | |
---|
| 559 | |
---|
| 560 | //-------------------------------------------------------------------------- |
---|
| 561 | bool OceanDemo::handleQuit(const CEGUI::EventArgs& e) |
---|
| 562 | { |
---|
| 563 | mRoot->queueEndRendering(); |
---|
| 564 | return true; |
---|
| 565 | } |
---|
| 566 | |
---|
| 567 | //-------------------------------------------------------------------------- |
---|
| 568 | void OceanDemo::setShaderControlVal(const float val, const size_t index) |
---|
| 569 | { |
---|
| 570 | char valTxtBuf[20]; |
---|
| 571 | |
---|
| 572 | // set the text of the value |
---|
| 573 | sprintf(valTxtBuf, "%3.3f", val ); |
---|
| 574 | mShaderControlContainer[index].NumberWidget->setText(valTxtBuf); |
---|
| 575 | } |
---|
| 576 | |
---|
| 577 | //-------------------------------------------------------------------------- |
---|
| 578 | bool OceanDemo::handleShaderControl(const CEGUI::EventArgs& e) |
---|
| 579 | { |
---|
| 580 | using namespace CEGUI; |
---|
| 581 | using namespace Ogre; |
---|
| 582 | |
---|
| 583 | |
---|
| 584 | size_t index = ((Scrollbar*)((const WindowEventArgs&)e).window)->getID(); |
---|
| 585 | const ShaderControl& ActiveShaderDef = mMaterialControlsContainer[mCurrentMaterial].getShaderControl(index); |
---|
| 586 | |
---|
| 587 | float val = ((Scrollbar*)((const WindowEventArgs&)e).window)->getScrollPosition(); |
---|
| 588 | val = ActiveShaderDef.convertScrollPositionToParam(val); |
---|
| 589 | setShaderControlVal( val, index ); |
---|
| 590 | |
---|
| 591 | if(mActivePass) |
---|
| 592 | { |
---|
| 593 | switch(ActiveShaderDef.ValType) |
---|
| 594 | { |
---|
| 595 | case GPU_VERTEX: |
---|
| 596 | case GPU_FRAGMENT: |
---|
| 597 | { |
---|
| 598 | GpuProgramParametersSharedPtr activeParameters = |
---|
| 599 | (ActiveShaderDef.ValType == GPU_VERTEX) ? |
---|
| 600 | mActiveVertexParameters : mActiveFragmentParameters; |
---|
| 601 | |
---|
| 602 | if(!activeParameters.isNull()) |
---|
| 603 | { |
---|
| 604 | activeParameters->_writeRawConstant( |
---|
| 605 | ActiveShaderDef.PhysicalIndex + ActiveShaderDef.ElementIndex, val); |
---|
| 606 | } |
---|
| 607 | } |
---|
| 608 | break; |
---|
| 609 | |
---|
| 610 | case MAT_SPECULAR: |
---|
| 611 | { |
---|
| 612 | // get the specular values from the material pass |
---|
| 613 | ColourValue OldSpec(mActivePass->getSpecular()); |
---|
| 614 | OldSpec[ActiveShaderDef.ElementIndex] = val; |
---|
| 615 | mActivePass->setSpecular( OldSpec ); |
---|
| 616 | } |
---|
| 617 | |
---|
| 618 | break; |
---|
| 619 | |
---|
| 620 | case MAT_DIFFUSE: |
---|
| 621 | { |
---|
| 622 | // get the specular values from the material pass |
---|
| 623 | ColourValue OldSpec(mActivePass->getDiffuse()); |
---|
| 624 | OldSpec[ActiveShaderDef.ElementIndex] = val; |
---|
| 625 | mActivePass->setDiffuse( OldSpec ); |
---|
| 626 | } |
---|
| 627 | break; |
---|
| 628 | |
---|
| 629 | case MAT_AMBIENT: |
---|
| 630 | { |
---|
| 631 | // get the specular values from the material pass |
---|
| 632 | ColourValue OldSpec(mActivePass->getAmbient()); |
---|
| 633 | OldSpec[ActiveShaderDef.ElementIndex] = val; |
---|
| 634 | mActivePass->setAmbient( OldSpec ); |
---|
| 635 | } |
---|
| 636 | break; |
---|
| 637 | |
---|
| 638 | case MAT_SHININESS: |
---|
| 639 | // get the specular values from the material pass |
---|
| 640 | mActivePass->setShininess( val ); |
---|
| 641 | break; |
---|
| 642 | } |
---|
| 643 | } |
---|
| 644 | |
---|
| 645 | return true; |
---|
| 646 | } |
---|
| 647 | |
---|
| 648 | //-------------------------------------------------------------------------- |
---|
| 649 | void OceanDemo::configureShaderControls(void) |
---|
| 650 | { |
---|
| 651 | using namespace CEGUI; |
---|
| 652 | |
---|
| 653 | if (mMaterialControlsContainer.empty()) return; |
---|
| 654 | |
---|
| 655 | mActiveMaterial = Ogre::MaterialManager::getSingleton().getByName( mMaterialControlsContainer[mCurrentMaterial].getMaterialName() ); |
---|
| 656 | if(!mActiveMaterial.isNull() && mActiveMaterial->getNumSupportedTechniques()) |
---|
| 657 | { |
---|
| 658 | Ogre::Technique* currentTechnique = mActiveMaterial->getSupportedTechnique(0); |
---|
| 659 | if(currentTechnique) |
---|
| 660 | { |
---|
| 661 | mActivePass = currentTechnique->getPass(0); |
---|
| 662 | if(mActivePass) |
---|
| 663 | { |
---|
| 664 | if (mActivePass->hasFragmentProgram()) |
---|
| 665 | { |
---|
| 666 | mActiveFragmentProgram = mActivePass->getFragmentProgram(); |
---|
| 667 | mActiveFragmentParameters = mActivePass->getFragmentProgramParameters(); |
---|
| 668 | } |
---|
| 669 | if (mActivePass->hasVertexProgram()) |
---|
| 670 | { |
---|
| 671 | mActiveVertexProgram = mActivePass->getVertexProgram(); |
---|
| 672 | mActiveVertexParameters = mActivePass->getVertexProgramParameters(); |
---|
| 673 | } |
---|
| 674 | |
---|
| 675 | size_t activeControlCount = mMaterialControlsContainer[mCurrentMaterial].getShaderControlCount(); |
---|
| 676 | mVertScroll->setDocumentSize( activeControlCount / 5.0f ); |
---|
| 677 | mVertScroll->setScrollPosition(0.0f); |
---|
| 678 | |
---|
| 679 | // init the GUI controls |
---|
| 680 | // check the material entry for Params GUI list |
---|
| 681 | if(mMaterialControlsContainer[mCurrentMaterial].getShaderControlCount() > 0) |
---|
| 682 | { |
---|
| 683 | // if mShaderControlContainer size < Params list |
---|
| 684 | if( activeControlCount > mShaderControlContainer.size()) |
---|
| 685 | { |
---|
| 686 | // resize container |
---|
| 687 | mShaderControlContainer.resize( activeControlCount ); |
---|
| 688 | } |
---|
| 689 | Window* controlWindow = WindowManager::getSingleton().getWindow("ShaderControlsWin"); |
---|
| 690 | // initialize each widget based on control data |
---|
| 691 | // iterate through the params GUI list |
---|
| 692 | for( size_t i=0; i < activeControlCount; ++i ) |
---|
| 693 | { |
---|
| 694 | const ShaderControl& ActiveShaderDef = mMaterialControlsContainer[mCurrentMaterial].getShaderControl(i); |
---|
| 695 | |
---|
| 696 | // if TextWidget is NULL |
---|
| 697 | Window* activeTextWidget = mShaderControlContainer[i].TextWidget; |
---|
| 698 | if(activeTextWidget == NULL) |
---|
| 699 | { |
---|
| 700 | // create TextWidget |
---|
| 701 | |
---|
| 702 | mShaderControlContainer[i].TextWidget = activeTextWidget = |
---|
| 703 | WindowManager::getSingleton().createWindow("TaharezLook/StaticText", |
---|
| 704 | ( ("UniformTxt" + Ogre::StringConverter::toString(i)).c_str() )); |
---|
| 705 | // add to Shader control window |
---|
| 706 | controlWindow->addChildWindow( activeTextWidget ); |
---|
| 707 | // set position based on its index |
---|
| 708 | activeTextWidget->setPosition(UVECTOR2(TEXTWIDGET_XPOS, WIDGET_YSTART + TEXTWIDGET_YADJUST + WIDGET_YOFFSET * float(i))); |
---|
| 709 | activeTextWidget->setProperty("VertFormatting", "TopAligned"); |
---|
| 710 | activeTextWidget->setProperty("HorzFormatting", "RightAligned"); |
---|
| 711 | activeTextWidget->setProperty("FrameEnabled", "false"); |
---|
| 712 | activeTextWidget->setInheritsAlpha(false); |
---|
| 713 | activeTextWidget->setProperty("BackgroundEnabled", "false"); |
---|
| 714 | activeTextWidget->setMaxSize( TEXTWIDGET_SIZE ); |
---|
| 715 | activeTextWidget->setMinSize( TEXTWIDGET_SIZE ); |
---|
| 716 | activeTextWidget->setSize( TEXTWIDGET_SIZE ); |
---|
| 717 | } |
---|
| 718 | |
---|
| 719 | // set TextWidget text to control name |
---|
| 720 | activeTextWidget->setText( ActiveShaderDef.Name.c_str() ); |
---|
| 721 | // make TextWidget visible |
---|
| 722 | activeTextWidget->show(); |
---|
| 723 | |
---|
| 724 | // if NumberWidget is NULL |
---|
| 725 | Window* activeNumberWidget = mShaderControlContainer[i].NumberWidget; |
---|
| 726 | if(activeNumberWidget == NULL) |
---|
| 727 | { |
---|
| 728 | // create NumberWidget |
---|
| 729 | |
---|
| 730 | mShaderControlContainer[i].NumberWidget = activeNumberWidget = |
---|
| 731 | WindowManager::getSingleton().createWindow("TaharezLook/StaticText", |
---|
| 732 | ( ("UniformNumTxt" + Ogre::StringConverter::toString(i)).c_str() )); |
---|
| 733 | // add to Shader control window |
---|
| 734 | controlWindow->addChildWindow( activeNumberWidget ); |
---|
| 735 | // set position based on its index |
---|
| 736 | activeNumberWidget->setPosition(UVECTOR2(NUMBERWIDGET_XPOS, WIDGET_YSTART + TEXTWIDGET_YADJUST + WIDGET_YOFFSET * float(i))); |
---|
| 737 | activeNumberWidget->setProperty("HorzFormatting", "RightAligned"); |
---|
| 738 | activeNumberWidget->setProperty("VertFormatting", "TopAligned"); |
---|
| 739 | activeNumberWidget->setProperty("FrameEnabled", "false"); |
---|
| 740 | activeNumberWidget->setInheritsAlpha(false); |
---|
| 741 | activeNumberWidget->setProperty("BackgroundEnabled", "false"); |
---|
| 742 | activeNumberWidget->setMaxSize( NUMBERWIDGET_SIZE ); |
---|
| 743 | activeNumberWidget->setMinSize( NUMBERWIDGET_SIZE ); |
---|
| 744 | activeNumberWidget->setSize( NUMBERWIDGET_SIZE ); |
---|
| 745 | } |
---|
| 746 | // make TextWidget visible |
---|
| 747 | activeNumberWidget->show(); |
---|
| 748 | |
---|
| 749 | Scrollbar* activeScrollWidget = mShaderControlContainer[i].ScrollWidget; |
---|
| 750 | // if ScrollWidget is NULL |
---|
| 751 | if( activeScrollWidget == NULL ) |
---|
| 752 | { |
---|
| 753 | // create ScrollWidget |
---|
| 754 | mShaderControlContainer[i].ScrollWidget = activeScrollWidget = |
---|
| 755 | (Scrollbar*)WindowManager::getSingleton().createWindow("TaharezLook/HorizontalScrollbar", |
---|
| 756 | ( ("UniformSB" + Ogre::StringConverter::toString(i)).c_str() )); |
---|
| 757 | // add to Shader control window |
---|
| 758 | controlWindow->addChildWindow( activeScrollWidget ); |
---|
| 759 | // set position based on its index |
---|
| 760 | activeScrollWidget->setPosition(UVECTOR2(SCROLLWIDGET_XPOS, WIDGET_YSTART + WIDGET_YOFFSET * float(i))); |
---|
| 761 | activeScrollWidget->setInheritsAlpha(false); |
---|
| 762 | activeScrollWidget->setMaxSize( SCROLLWIDGET_SIZE ); |
---|
| 763 | activeScrollWidget->setMinSize( SCROLLWIDGET_SIZE ); |
---|
| 764 | activeScrollWidget->setSize( SCROLLWIDGET_SIZE ); |
---|
| 765 | activeScrollWidget->setID( static_cast<CEGUI::uint>(i) ); |
---|
| 766 | activeScrollWidget->setOverlapSize(0); |
---|
| 767 | // wire up ScrollWidget position changed event to handleShaderControl |
---|
| 768 | activeScrollWidget->subscribeEvent(Scrollbar::EventScrollPositionChanged, CEGUI::Event::Subscriber(&OceanDemo::handleShaderControl, this )); } |
---|
| 769 | // set max value of ScrollWidget |
---|
| 770 | float maxval = ActiveShaderDef.getRange(); |
---|
| 771 | activeScrollWidget->setDocumentSize(maxval); |
---|
| 772 | activeScrollWidget->setPageSize(0.000); |
---|
| 773 | activeScrollWidget->setStepSize(maxval/20); |
---|
| 774 | // get current value of param |
---|
| 775 | |
---|
| 776 | float uniformVal = 0.0; |
---|
| 777 | |
---|
| 778 | switch(ActiveShaderDef.ValType) |
---|
| 779 | { |
---|
| 780 | case GPU_VERTEX: |
---|
| 781 | case GPU_FRAGMENT: |
---|
| 782 | { |
---|
| 783 | Ogre::GpuProgramParametersSharedPtr activeParameters = |
---|
| 784 | (ActiveShaderDef.ValType == Ogre::GPT_VERTEX_PROGRAM) ? |
---|
| 785 | mActiveVertexParameters : mActiveFragmentParameters; |
---|
| 786 | if(!activeParameters.isNull()) |
---|
| 787 | { |
---|
| 788 | // use param name to get index : use appropiate paramters ptr |
---|
| 789 | const Ogre::GpuConstantDefinition& def = |
---|
| 790 | activeParameters->getConstantDefinition(ActiveShaderDef.ParamName); |
---|
| 791 | ActiveShaderDef.PhysicalIndex = def.physicalIndex; |
---|
| 792 | // use index to get RealConstantEntry |
---|
| 793 | const float* pFloat = activeParameters->getFloatPointer(ActiveShaderDef.PhysicalIndex); |
---|
| 794 | // set position of ScrollWidget as param value |
---|
| 795 | uniformVal = pFloat[ActiveShaderDef.ElementIndex]; |
---|
| 796 | activeScrollWidget->setScrollPosition( ActiveShaderDef.convertParamToScrollPosition(uniformVal) ); |
---|
| 797 | } |
---|
| 798 | } |
---|
| 799 | break; |
---|
| 800 | |
---|
| 801 | case MAT_SPECULAR: |
---|
| 802 | { |
---|
| 803 | // get the specular values from the material pass |
---|
| 804 | |
---|
| 805 | Ogre::ColourValue OldSpec(mActivePass->getSpecular()); |
---|
| 806 | uniformVal = OldSpec[ActiveShaderDef.ElementIndex]; |
---|
| 807 | activeScrollWidget->setScrollPosition( ActiveShaderDef.convertParamToScrollPosition(uniformVal) ); |
---|
| 808 | } |
---|
| 809 | break; |
---|
| 810 | |
---|
| 811 | case MAT_DIFFUSE: |
---|
| 812 | { |
---|
| 813 | // get the diffuse values from the material pass |
---|
| 814 | |
---|
| 815 | Ogre::ColourValue OldSpec(mActivePass->getDiffuse()); |
---|
| 816 | uniformVal = OldSpec[ActiveShaderDef.ElementIndex]; |
---|
| 817 | activeScrollWidget->setScrollPosition( ActiveShaderDef.convertParamToScrollPosition(uniformVal) ); |
---|
| 818 | } |
---|
| 819 | break; |
---|
| 820 | |
---|
| 821 | case MAT_AMBIENT: |
---|
| 822 | { |
---|
| 823 | // get the ambient values from the material pass |
---|
| 824 | |
---|
| 825 | Ogre::ColourValue OldSpec(mActivePass->getAmbient()); |
---|
| 826 | uniformVal = OldSpec[ActiveShaderDef.ElementIndex]; |
---|
| 827 | activeScrollWidget->setScrollPosition( ActiveShaderDef.convertParamToScrollPosition(uniformVal) ); |
---|
| 828 | } |
---|
| 829 | break; |
---|
| 830 | |
---|
| 831 | case MAT_SHININESS: |
---|
| 832 | { |
---|
| 833 | // get the ambient values from the material pass |
---|
| 834 | |
---|
| 835 | uniformVal = mActivePass->getShininess(); |
---|
| 836 | activeScrollWidget->setScrollPosition( ActiveShaderDef.convertParamToScrollPosition(uniformVal) ); |
---|
| 837 | } |
---|
| 838 | |
---|
| 839 | break; |
---|
| 840 | |
---|
| 841 | case MAT_EMISSIVE: |
---|
| 842 | { |
---|
| 843 | // get the ambient values from the material pass |
---|
| 844 | |
---|
| 845 | //ColourValue OldSpec(mActivePass->gete()); |
---|
| 846 | //activeScrollWidget->setScrollPosition( OldSpec.val[ActiveShaderDef->ElementIndex] ); |
---|
| 847 | } |
---|
| 848 | break; |
---|
| 849 | } |
---|
| 850 | |
---|
| 851 | setShaderControlVal( uniformVal, i ); |
---|
| 852 | activeScrollWidget->show(); |
---|
| 853 | } // end of iterate |
---|
| 854 | } |
---|
| 855 | |
---|
| 856 | // turn off extra GUI widgets |
---|
| 857 | // iterate from 1 + active widgets to end |
---|
| 858 | for( size_t i = activeControlCount; i < mShaderControlContainer.size(); i++ ) |
---|
| 859 | { |
---|
| 860 | // hide widget |
---|
| 861 | if( mShaderControlContainer[i].TextWidget != NULL ) |
---|
| 862 | { |
---|
| 863 | mShaderControlContainer[i].TextWidget->hide(); |
---|
| 864 | } |
---|
| 865 | |
---|
| 866 | if( mShaderControlContainer[i].NumberWidget != NULL ) |
---|
| 867 | { |
---|
| 868 | mShaderControlContainer[i].NumberWidget->hide(); |
---|
| 869 | } |
---|
| 870 | |
---|
| 871 | { |
---|
| 872 | mShaderControlContainer[i].ScrollWidget->hide(); |
---|
| 873 | } |
---|
| 874 | |
---|
| 875 | }// end of iterate |
---|
| 876 | |
---|
| 877 | } |
---|
| 878 | } |
---|
| 879 | } |
---|
| 880 | |
---|
| 881 | } |
---|
| 882 | |
---|
| 883 | //-------------------------------------------------------------------------- |
---|
| 884 | bool OceanDemo::handleModelComboChanged(const CEGUI::EventArgs& e) |
---|
| 885 | { |
---|
| 886 | using namespace CEGUI; |
---|
| 887 | |
---|
| 888 | // get the selected mesh filename from the combo box |
---|
| 889 | CEGUI::ListboxItem* item = ((Combobox*)((const WindowEventArgs&)e).window)->getSelectedItem(); |
---|
| 890 | |
---|
| 891 | // convert from CEGUI::String to Ogre::String |
---|
| 892 | Ogre::String meshName(item->getText().c_str()); |
---|
| 893 | |
---|
| 894 | // hide the current entity |
---|
| 895 | if (mCurrentEntity) |
---|
| 896 | { |
---|
| 897 | mCurrentEntity->setVisible(false); |
---|
| 898 | // disconnect the entity from the scenenode |
---|
| 899 | mMainNode->detachObject(mCurrentEntity->getName()); |
---|
| 900 | } |
---|
| 901 | |
---|
| 902 | // find the entity selected in combo box |
---|
| 903 | // an exception is raised by getEntity if it doesn't exist |
---|
| 904 | // so trap the exception if entity not found and load it |
---|
| 905 | try |
---|
| 906 | { |
---|
| 907 | mCurrentEntity = mSceneMgr->getEntity( meshName ); |
---|
| 908 | } |
---|
| 909 | catch (Ogre::Exception e) |
---|
| 910 | // if not found create it |
---|
| 911 | { |
---|
| 912 | Ogre::MeshPtr pMesh = Ogre::MeshManager::getSingleton().load(meshName, Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME |
---|
| 913 | //Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY, |
---|
| 914 | //Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY, |
---|
| 915 | //true, true |
---|
| 916 | ); //so we can still read it |
---|
| 917 | // Build tangent vectors, all our meshes use only 1 texture coordset |
---|
| 918 | //pMesh->buildTangentVectors(0, 1); |
---|
| 919 | // Create entity |
---|
| 920 | mCurrentEntity = mSceneMgr->createEntity(meshName, meshName); |
---|
| 921 | } |
---|
| 922 | |
---|
| 923 | // make the entity visible and attach it to our main scenenode |
---|
| 924 | mCurrentEntity->setVisible(true); |
---|
| 925 | mMainNode->attachObject(mCurrentEntity); |
---|
| 926 | |
---|
| 927 | // set the the entity's material to the current material |
---|
| 928 | //mCurrentEntity->setMaterialName(mMaterialControlsContainer[mCurrentMaterial].getMaterialName()); |
---|
| 929 | configureShaderControls(); |
---|
| 930 | return true; |
---|
| 931 | } |
---|
| 932 | |
---|
| 933 | //-------------------------------------------------------------------------- |
---|
| 934 | bool OceanDemo::handleShaderComboChanged(const CEGUI::EventArgs& e) |
---|
| 935 | { |
---|
| 936 | using namespace CEGUI; |
---|
| 937 | |
---|
| 938 | CEGUI::ListboxItem* item = ((Combobox*)((const WindowEventArgs&)e).window)->getSelectedItem(); |
---|
| 939 | |
---|
| 940 | mCurrentMaterial = item->getID(); |
---|
| 941 | if (mOceanSurfaceEnt) |
---|
| 942 | mOceanSurfaceEnt->setMaterialName(mMaterialControlsContainer[mCurrentMaterial].getMaterialName()); |
---|
| 943 | configureShaderControls(); |
---|
| 944 | |
---|
| 945 | return true; |
---|
| 946 | } |
---|
| 947 | |
---|
| 948 | |
---|
| 949 | //-------------------------------------------------------------------------- |
---|
| 950 | bool OceanDemo::handleScrollControlsWindow(const CEGUI::EventArgs& e) |
---|
| 951 | { |
---|
| 952 | using namespace CEGUI; |
---|
| 953 | |
---|
| 954 | size_t controlCount = mShaderControlContainer.size(); |
---|
| 955 | float scrollval = ((Scrollbar*)((const WindowEventArgs&)e).window)->getScrollPosition(); |
---|
| 956 | |
---|
| 957 | for (size_t i = 0; i < controlCount; i++) |
---|
| 958 | { |
---|
| 959 | float ypos = WIDGET_YSTART + WIDGET_YOFFSET * float(i) - scrollval; |
---|
| 960 | mShaderControlContainer[i].TextWidget->setPosition(UVECTOR2( TEXTWIDGET_XPOS, ypos + TEXTWIDGET_YADJUST)); |
---|
| 961 | mShaderControlContainer[i].NumberWidget->setPosition(UVECTOR2( NUMBERWIDGET_XPOS, ypos + TEXTWIDGET_YADJUST)); |
---|
| 962 | mShaderControlContainer[i].ScrollWidget->setPosition(UVECTOR2( SCROLLWIDGET_XPOS, ypos )); |
---|
| 963 | } |
---|
| 964 | |
---|
| 965 | return true; |
---|
| 966 | } |
---|
| 967 | |
---|
| 968 | //-------------------------------------------------------------------------- |
---|
| 969 | bool OceanDemo::handleMovementTypeChange(const CEGUI::EventArgs& e) |
---|
| 970 | { |
---|
| 971 | using namespace CEGUI; |
---|
| 972 | CEGUI::uint id = ((RadioButton*)((const WindowEventArgs&)e).window)->getSelectedButtonInGroup()->getID(); |
---|
| 973 | if (id == 0) |
---|
| 974 | { |
---|
| 975 | mMouseMovement = mv_CAMERA; |
---|
| 976 | } |
---|
| 977 | else |
---|
| 978 | { |
---|
| 979 | mMouseMovement = mv_MODEL; |
---|
| 980 | } |
---|
| 981 | |
---|
| 982 | return true; |
---|
| 983 | } |
---|
| 984 | |
---|
| 985 | |
---|
| 986 | //-------------------------------------------------------------------------- |
---|
| 987 | bool OceanDemo::handleErrorBox(const CEGUI::EventArgs& e) |
---|
| 988 | { |
---|
| 989 | CEGUI::WindowManager::getSingleton().getWindow((CEGUI::utf8*)"ErrorBox")->hide(); |
---|
| 990 | return true; |
---|
| 991 | } |
---|
| 992 | |
---|
| 993 | //-------------------------------------------------------------------------- |
---|
| 994 | void OceanDemo::createFrameListener(void) |
---|
| 995 | { |
---|
| 996 | mFrameListener= new OceanDemo_FrameListener(this); |
---|
| 997 | mRoot->addFrameListener(mFrameListener); |
---|
| 998 | } |
---|
| 999 | |
---|
| 1000 | |
---|
| 1001 | /************************************************************************* |
---|
| 1002 | OceanDemo_FrameListener methods that handle all input for this GLSL demo. |
---|
| 1003 | *************************************************************************/ |
---|
| 1004 | |
---|
| 1005 | OceanDemo_FrameListener::OceanDemo_FrameListener(OceanDemo* main) |
---|
| 1006 | : mMain(main) |
---|
| 1007 | , mStatsOn(true) |
---|
| 1008 | , mWriteToFile(false) |
---|
| 1009 | , mLastMousePositionSet(false) |
---|
| 1010 | , mSpinModel(true) |
---|
| 1011 | , mSpinLight(false) |
---|
| 1012 | , mMouse(0) |
---|
| 1013 | , mKeyboard(0) |
---|
| 1014 | , mLMBDown(false) |
---|
| 1015 | , mRMBDown(false) |
---|
| 1016 | , mProcessMovement(false) |
---|
| 1017 | , mUpdateMovement(false) |
---|
| 1018 | , mMoveFwd(false) |
---|
| 1019 | , mMoveBck(false) |
---|
| 1020 | , mMoveLeft(false) |
---|
| 1021 | , mMoveRight(false) |
---|
| 1022 | |
---|
| 1023 | { |
---|
| 1024 | mRotateSpeed = 0; |
---|
| 1025 | mMoveSpeed = 100; |
---|
| 1026 | |
---|
| 1027 | mNumScreenShots = 0; |
---|
| 1028 | mTimeUntilNextToggle = 0; |
---|
| 1029 | mSceneDetailIndex = 0; |
---|
| 1030 | mMoveScale = 0.0f; |
---|
| 1031 | mSpeed = MINSPEED; |
---|
| 1032 | mRotX = 0; |
---|
| 1033 | mRotY = 0; |
---|
| 1034 | mRotScale = 0.0f; |
---|
| 1035 | mTranslateVector = Ogre::Vector3::ZERO; |
---|
| 1036 | mAniso = 1; |
---|
| 1037 | mFiltering = Ogre::TFO_BILINEAR; |
---|
| 1038 | mAvgFrameTime = 0.1; |
---|
| 1039 | |
---|
| 1040 | // using buffered input |
---|
| 1041 | OIS::ParamList pl; |
---|
| 1042 | size_t windowHnd = 0; |
---|
| 1043 | std::ostringstream windowHndStr; |
---|
| 1044 | mMain->getRenderWindow()->getCustomAttribute("WINDOW", &windowHnd); |
---|
| 1045 | windowHndStr << windowHnd; |
---|
| 1046 | pl.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str())); |
---|
| 1047 | |
---|
| 1048 | mInputManager = OIS::InputManager::createInputSystem( pl ); |
---|
| 1049 | //Create all devices (We only catch joystick exceptions here, as, most people have Key/Mouse) |
---|
| 1050 | mKeyboard = static_cast<OIS::Keyboard*>(mInputManager->createInputObject( OIS::OISKeyboard, true )); |
---|
| 1051 | mMouse = static_cast<OIS::Mouse*>(mInputManager->createInputObject( OIS::OISMouse, true )); |
---|
| 1052 | |
---|
| 1053 | unsigned int width, height, depth; |
---|
| 1054 | int left, top; |
---|
| 1055 | mMain->getRenderWindow()->getMetrics(width, height, depth, left, top); |
---|
| 1056 | |
---|
| 1057 | //Set Mouse Region.. if window resizes, we should alter this to reflect as well |
---|
| 1058 | const OIS::MouseState &ms = mMouse->getMouseState(); |
---|
| 1059 | ms.width = width; |
---|
| 1060 | ms.height = height; |
---|
| 1061 | |
---|
| 1062 | mMouse->setEventCallback(this); |
---|
| 1063 | mKeyboard->setEventCallback(this); |
---|
| 1064 | |
---|
| 1065 | mQuit = false; |
---|
| 1066 | mSkipCount = 0; |
---|
| 1067 | mUpdateFreq = 50; |
---|
| 1068 | |
---|
| 1069 | mGuiRenderer = CEGUI::System::getSingleton().getRenderer(); |
---|
| 1070 | |
---|
| 1071 | mGuiAvg = CEGUI::WindowManager::getSingleton().getWindow("OPAverageFPS"); |
---|
| 1072 | mGuiCurr = CEGUI::WindowManager::getSingleton().getWindow("OPCurrentFPS"); |
---|
| 1073 | mGuiBest = CEGUI::WindowManager::getSingleton().getWindow("OPBestFPS"); |
---|
| 1074 | mGuiWorst = CEGUI::WindowManager::getSingleton().getWindow("OPWorstFPS"); |
---|
| 1075 | mGuiTris = CEGUI::WindowManager::getSingleton().getWindow("OPTriCount"); |
---|
| 1076 | mGuiDbg = CEGUI::WindowManager::getSingleton().getWindow("OPDebugMsg"); |
---|
| 1077 | mRoot = CEGUI::WindowManager::getSingleton().getWindow("root"); |
---|
| 1078 | } |
---|
| 1079 | |
---|
| 1080 | //-------------------------------------------------------------------------- |
---|
| 1081 | OceanDemo_FrameListener::~OceanDemo_FrameListener() |
---|
| 1082 | { |
---|
| 1083 | if(mInputManager) |
---|
| 1084 | { |
---|
| 1085 | mInputManager->destroyInputObject(mMouse); |
---|
| 1086 | mInputManager->destroyInputObject(mKeyboard); |
---|
| 1087 | OIS::InputManager::destroyInputSystem(mInputManager); |
---|
| 1088 | mInputManager = 0; |
---|
| 1089 | } |
---|
| 1090 | } |
---|
| 1091 | |
---|
| 1092 | |
---|
| 1093 | //-------------------------------------------------------------------------- |
---|
| 1094 | bool OceanDemo_FrameListener::frameStarted(const Ogre::FrameEvent& evt) |
---|
| 1095 | { |
---|
| 1096 | mMouse->capture(); |
---|
| 1097 | mKeyboard->capture(); |
---|
| 1098 | |
---|
| 1099 | if (mQuit) |
---|
| 1100 | return false; |
---|
| 1101 | else |
---|
| 1102 | { |
---|
| 1103 | mSkipCount++; |
---|
| 1104 | if (mSkipCount >= mUpdateFreq) |
---|
| 1105 | { |
---|
| 1106 | mSkipCount = 0; |
---|
| 1107 | updateStats(); |
---|
| 1108 | } |
---|
| 1109 | // update movement process |
---|
| 1110 | if(mProcessMovement || mUpdateMovement) |
---|
| 1111 | { |
---|
| 1112 | mTranslateVector.x += mMoveLeft ? mAvgFrameTime * -MOVESPEED : 0; |
---|
| 1113 | mTranslateVector.x += mMoveRight ? mAvgFrameTime * MOVESPEED : 0; |
---|
| 1114 | mTranslateVector.z += mMoveFwd ? mAvgFrameTime * -MOVESPEED : 0; |
---|
| 1115 | mTranslateVector.z += mMoveBck ? mAvgFrameTime * MOVESPEED : 0; |
---|
| 1116 | switch(mMain->getMouseMovement()) |
---|
| 1117 | { |
---|
| 1118 | case mv_CAMERA: |
---|
| 1119 | mMain->getCamera()->yaw(Ogre::Angle(mRotX)); |
---|
| 1120 | mMain->getCamera()->pitch(Ogre::Angle(mRotY)); |
---|
| 1121 | mMain->getCamera()->moveRelative(mTranslateVector); |
---|
| 1122 | break; |
---|
| 1123 | |
---|
| 1124 | case mv_MODEL: |
---|
| 1125 | mMain->getMainNode()->yaw(Ogre::Angle(mRotX)); |
---|
| 1126 | //mMain->getMainNode()->pitch(mRotY); |
---|
| 1127 | mMain->getMainNode()->translate(mTranslateVector); |
---|
| 1128 | break; |
---|
| 1129 | default: |
---|
| 1130 | break; |
---|
| 1131 | } |
---|
| 1132 | |
---|
| 1133 | mUpdateMovement = false; |
---|
| 1134 | mRotX = 0; |
---|
| 1135 | mRotY = 0; |
---|
| 1136 | mTranslateVector = Ogre::Vector3::ZERO; |
---|
| 1137 | } |
---|
| 1138 | |
---|
| 1139 | if(mSpinModel) |
---|
| 1140 | { |
---|
| 1141 | mRotateSpeed = mAvgFrameTime * 20; |
---|
| 1142 | mMain->getMainNode()->yaw( Ogre::Angle(mRotateSpeed) ); |
---|
| 1143 | } |
---|
| 1144 | if(mSpinLight) |
---|
| 1145 | { |
---|
| 1146 | mLightPivots[0]->rotate(mLightRotationAxes[0], Ogre::Angle(mRotateSpeed * 2.0f)); |
---|
| 1147 | } |
---|
| 1148 | if(mWriteToFile) |
---|
| 1149 | { |
---|
| 1150 | char tmp[20]; |
---|
| 1151 | sprintf(tmp, "frame_%d.png", ++mNumScreenShots); |
---|
| 1152 | mMain->getRenderWindow()->writeContentsToFile(tmp); |
---|
| 1153 | } |
---|
| 1154 | return true; |
---|
| 1155 | } |
---|
| 1156 | } |
---|
| 1157 | |
---|
| 1158 | //-------------------------------------------------------------------------- |
---|
| 1159 | bool OceanDemo_FrameListener::mouseMoved (const OIS::MouseEvent &e) |
---|
| 1160 | { |
---|
| 1161 | CEGUI::System::getSingleton().injectMouseMove( e.state.X.rel, e.state.Y.rel ); |
---|
| 1162 | CEGUI::System::getSingleton().injectMouseWheelChange(e.state.Z.rel); |
---|
| 1163 | return true; |
---|
| 1164 | } |
---|
| 1165 | |
---|
| 1166 | //-------------------------------------------------------------------------- |
---|
| 1167 | bool OceanDemo_FrameListener::keyPressed (const OIS::KeyEvent &e) |
---|
| 1168 | { |
---|
| 1169 | // give 'quitting' priority |
---|
| 1170 | if (e.key == OIS::KC_ESCAPE) |
---|
| 1171 | { |
---|
| 1172 | mQuit = true; |
---|
| 1173 | return false; |
---|
| 1174 | } |
---|
| 1175 | |
---|
| 1176 | if (e.key == OIS::KC_SYSRQ ) |
---|
| 1177 | { |
---|
| 1178 | std::ostringstream ss; |
---|
| 1179 | ss << "screenshot_" << ++mNumScreenShots << ".png"; |
---|
| 1180 | mMain->getRenderWindow()->writeContentsToFile(ss.str()); |
---|
| 1181 | //mTimeUntilNextToggle = 0.5; |
---|
| 1182 | mDebugText = "Saved: " + ss.str(); |
---|
| 1183 | } |
---|
| 1184 | |
---|
| 1185 | // do event injection |
---|
| 1186 | CEGUI::System& cegui = CEGUI::System::getSingleton(); |
---|
| 1187 | cegui.injectKeyDown(e.key); |
---|
| 1188 | cegui.injectChar(e.text); |
---|
| 1189 | return true; |
---|
| 1190 | } |
---|
| 1191 | |
---|
| 1192 | //-------------------------------------------------------------------------- |
---|
| 1193 | bool OceanDemo_FrameListener::keyReleased (const OIS::KeyEvent &e) |
---|
| 1194 | { |
---|
| 1195 | CEGUI::System::getSingleton().injectKeyUp(e.key); |
---|
| 1196 | return true; |
---|
| 1197 | } |
---|
| 1198 | |
---|
| 1199 | //-------------------------------------------------------------------------- |
---|
| 1200 | bool OceanDemo_FrameListener::mousePressed (const OIS::MouseEvent &e, OIS::MouseButtonID id) |
---|
| 1201 | { |
---|
| 1202 | CEGUI::System::getSingleton().injectMouseButtonDown(convertOISButtonToCegui(id)); |
---|
| 1203 | return true; |
---|
| 1204 | } |
---|
| 1205 | |
---|
| 1206 | //-------------------------------------------------------------------------- |
---|
| 1207 | bool OceanDemo_FrameListener::mouseReleased (const OIS::MouseEvent &e, OIS::MouseButtonID id) |
---|
| 1208 | { |
---|
| 1209 | CEGUI::System::getSingleton().injectMouseButtonUp(convertOISButtonToCegui(id)); |
---|
| 1210 | return true; |
---|
| 1211 | } |
---|
| 1212 | |
---|
| 1213 | //-------------------------------------------------------------------------- |
---|
| 1214 | CEGUI::MouseButton OceanDemo_FrameListener::convertOISButtonToCegui(int ois_button_id) |
---|
| 1215 | { |
---|
| 1216 | switch (ois_button_id) |
---|
| 1217 | { |
---|
| 1218 | case 0: return CEGUI::LeftButton; |
---|
| 1219 | case 1: return CEGUI::RightButton; |
---|
| 1220 | case 2: return CEGUI::MiddleButton; |
---|
| 1221 | case 3: return CEGUI::X1Button; |
---|
| 1222 | default: return CEGUI::LeftButton; |
---|
| 1223 | } |
---|
| 1224 | } |
---|
| 1225 | //-------------------------------------------------------------------------- |
---|
| 1226 | void OceanDemo_FrameListener::updateStats(void) |
---|
| 1227 | { |
---|
| 1228 | static CEGUI::String currFps = "Current FPS: "; |
---|
| 1229 | static CEGUI::String avgFps = "Average FPS: "; |
---|
| 1230 | static CEGUI::String bestFps = "Best FPS: "; |
---|
| 1231 | static CEGUI::String worstFps = "Worst FPS: "; |
---|
| 1232 | static CEGUI::String tris = "Triangle Count: "; |
---|
| 1233 | |
---|
| 1234 | |
---|
| 1235 | const Ogre::RenderTarget::FrameStats& stats = mMain->getRenderWindow()->getStatistics(); |
---|
| 1236 | |
---|
| 1237 | mGuiAvg->setText(avgFps + Ogre::StringConverter::toString(stats.avgFPS)); |
---|
| 1238 | mGuiCurr->setText(currFps + Ogre::StringConverter::toString(stats.lastFPS)); |
---|
| 1239 | mGuiBest->setText(bestFps + Ogre::StringConverter::toString(stats.bestFPS) |
---|
| 1240 | + " " + Ogre::StringConverter::toString(stats.bestFrameTime)+" ms"); |
---|
| 1241 | mGuiWorst->setText(worstFps + Ogre::StringConverter::toString(stats.worstFPS) |
---|
| 1242 | + " " + Ogre::StringConverter::toString(stats.worstFrameTime)+" ms"); |
---|
| 1243 | |
---|
| 1244 | mGuiTris->setText(tris + Ogre::StringConverter::toString(stats.triangleCount)); |
---|
| 1245 | mGuiDbg->setText(mDebugText); |
---|
| 1246 | mAvgFrameTime = 1.0f/(stats.avgFPS + 1.0f); |
---|
| 1247 | if (mAvgFrameTime > 0.1f) mAvgFrameTime = 0.1f; |
---|
| 1248 | |
---|
| 1249 | } |
---|
| 1250 | |
---|
| 1251 | |
---|
| 1252 | //-------------------------------------------------------------------------- |
---|
| 1253 | bool OceanDemo_FrameListener::handleMouseMove(const CEGUI::EventArgs& e) |
---|
| 1254 | { |
---|
| 1255 | using namespace CEGUI; |
---|
| 1256 | |
---|
| 1257 | if( mLMBDown && !mRMBDown) |
---|
| 1258 | { |
---|
| 1259 | // rotate camera |
---|
| 1260 | mRotX += -((const MouseEventArgs&)e).moveDelta.d_x * mAvgFrameTime * 10.0; |
---|
| 1261 | mRotY += -((const MouseEventArgs&)e).moveDelta.d_y * mAvgFrameTime * 10.0; |
---|
| 1262 | MouseCursor::getSingleton().setPosition( mLastMousePosition ); |
---|
| 1263 | mUpdateMovement = true; |
---|
| 1264 | } |
---|
| 1265 | else |
---|
| 1266 | { |
---|
| 1267 | if( mRMBDown && !mLMBDown) |
---|
| 1268 | { |
---|
| 1269 | // translate camera |
---|
| 1270 | mTranslateVector.x += ((const MouseEventArgs&)e).moveDelta.d_x * mAvgFrameTime * MOVESPEED; |
---|
| 1271 | mTranslateVector.y += -((const MouseEventArgs&)e).moveDelta.d_y * mAvgFrameTime * MOVESPEED; |
---|
| 1272 | //mTranslateVector.z = 0; |
---|
| 1273 | MouseCursor::getSingleton().setPosition( mLastMousePosition ); |
---|
| 1274 | mUpdateMovement = true; |
---|
| 1275 | } |
---|
| 1276 | else |
---|
| 1277 | { |
---|
| 1278 | if( mRMBDown && mLMBDown) |
---|
| 1279 | { |
---|
| 1280 | mTranslateVector.z += (((const MouseEventArgs&)e).moveDelta.d_x + ((const MouseEventArgs&)e).moveDelta.d_y) * mAvgFrameTime * MOVESPEED; |
---|
| 1281 | MouseCursor::getSingleton().setPosition( mLastMousePosition ); |
---|
| 1282 | mUpdateMovement = true; |
---|
| 1283 | } |
---|
| 1284 | |
---|
| 1285 | } |
---|
| 1286 | } |
---|
| 1287 | |
---|
| 1288 | return true; |
---|
| 1289 | } |
---|
| 1290 | |
---|
| 1291 | //-------------------------------------------------------------------------- |
---|
| 1292 | bool OceanDemo_FrameListener::handleMouseButtonUp(const CEGUI::EventArgs& e) |
---|
| 1293 | { |
---|
| 1294 | using namespace CEGUI; |
---|
| 1295 | |
---|
| 1296 | //Window* wndw = ((const WindowEventArgs&)e).window; |
---|
| 1297 | if( ((const MouseEventArgs&)e).button == LeftButton ) |
---|
| 1298 | { |
---|
| 1299 | mLMBDown = false; |
---|
| 1300 | } |
---|
| 1301 | |
---|
| 1302 | if( ((const MouseEventArgs&)e).button == RightButton ) |
---|
| 1303 | { |
---|
| 1304 | mRMBDown = false; |
---|
| 1305 | } |
---|
| 1306 | if( !mLMBDown && !mRMBDown ) |
---|
| 1307 | { |
---|
| 1308 | MouseCursor::getSingleton().show(); |
---|
| 1309 | if(mLastMousePositionSet) |
---|
| 1310 | { |
---|
| 1311 | MouseCursor::getSingleton().setPosition( mLastMousePosition ); |
---|
| 1312 | mLastMousePositionSet = false; |
---|
| 1313 | } |
---|
| 1314 | mRoot->releaseInput(); |
---|
| 1315 | } |
---|
| 1316 | |
---|
| 1317 | return true; |
---|
| 1318 | } |
---|
| 1319 | |
---|
| 1320 | //-------------------------------------------------------------------------- |
---|
| 1321 | bool OceanDemo_FrameListener::handleMouseButtonDown(const CEGUI::EventArgs& e) |
---|
| 1322 | { |
---|
| 1323 | using namespace CEGUI; |
---|
| 1324 | |
---|
| 1325 | //Window* wndw = ((const WindowEventArgs&)e).window; |
---|
| 1326 | if( ((const MouseEventArgs&)e).button == LeftButton ) |
---|
| 1327 | { |
---|
| 1328 | mLMBDown = true; |
---|
| 1329 | } |
---|
| 1330 | |
---|
| 1331 | if( ((const MouseEventArgs&)e).button == RightButton ) |
---|
| 1332 | { |
---|
| 1333 | mRMBDown = true; |
---|
| 1334 | } |
---|
| 1335 | |
---|
| 1336 | if( mLMBDown || mRMBDown ) |
---|
| 1337 | { |
---|
| 1338 | MouseCursor::getSingleton().hide(); |
---|
| 1339 | if (!mLastMousePositionSet) |
---|
| 1340 | { |
---|
| 1341 | mLastMousePosition = MouseCursor::getSingleton().getPosition(); |
---|
| 1342 | mLastMousePositionSet = true; |
---|
| 1343 | } |
---|
| 1344 | mRoot->captureInput(); |
---|
| 1345 | } |
---|
| 1346 | |
---|
| 1347 | return true; |
---|
| 1348 | } |
---|
| 1349 | |
---|
| 1350 | //-------------------------------------------------------------------------- |
---|
| 1351 | bool OceanDemo_FrameListener::handleMouseWheelEvent(const CEGUI::EventArgs& e) |
---|
| 1352 | { |
---|
| 1353 | using namespace CEGUI; |
---|
| 1354 | mTranslateVector.z += ((const MouseEventArgs&)e).wheelChange * -5.0; |
---|
| 1355 | mUpdateMovement = true; |
---|
| 1356 | |
---|
| 1357 | return true; |
---|
| 1358 | } |
---|
| 1359 | |
---|
| 1360 | //-------------------------------------------------------------------------- |
---|
| 1361 | bool OceanDemo_FrameListener::handleKeyDownEvent(const CEGUI::EventArgs& e) |
---|
| 1362 | { |
---|
| 1363 | using namespace CEGUI; |
---|
| 1364 | |
---|
| 1365 | CheckMovementKeys( ((const KeyEventArgs&)e).scancode , true); |
---|
| 1366 | |
---|
| 1367 | return true; |
---|
| 1368 | } |
---|
| 1369 | |
---|
| 1370 | //-------------------------------------------------------------------------- |
---|
| 1371 | bool OceanDemo_FrameListener::handleKeyUpEvent(const CEGUI::EventArgs& e) |
---|
| 1372 | { |
---|
| 1373 | using namespace CEGUI; |
---|
| 1374 | CheckMovementKeys( ((const KeyEventArgs&)e).scancode, false ); |
---|
| 1375 | |
---|
| 1376 | return true; |
---|
| 1377 | } |
---|
| 1378 | |
---|
| 1379 | |
---|
| 1380 | //-------------------------------------------------------------------------- |
---|
| 1381 | bool OceanDemo_FrameListener::handelModelSpinChange(const CEGUI::EventArgs& e) |
---|
| 1382 | { |
---|
| 1383 | using namespace CEGUI; |
---|
| 1384 | mSpinModel = ((Checkbox*)((const WindowEventArgs&)e).window)->isSelected(); |
---|
| 1385 | |
---|
| 1386 | return true; |
---|
| 1387 | } |
---|
| 1388 | |
---|
| 1389 | //-------------------------------------------------------------------------- |
---|
| 1390 | bool OceanDemo_FrameListener::handelLightSpinChange(const CEGUI::EventArgs& e) |
---|
| 1391 | { |
---|
| 1392 | using namespace CEGUI; |
---|
| 1393 | mSpinLight = ((Checkbox*)((const WindowEventArgs&)e).window)->isSelected(); |
---|
| 1394 | |
---|
| 1395 | return true; |
---|
| 1396 | } |
---|
| 1397 | |
---|
| 1398 | //-------------------------------------------------------------------------- |
---|
| 1399 | void OceanDemo_FrameListener::CheckMovementKeys( CEGUI::Key::Scan scancode, bool state ) |
---|
| 1400 | { |
---|
| 1401 | using namespace CEGUI; |
---|
| 1402 | |
---|
| 1403 | switch ( scancode ) |
---|
| 1404 | { |
---|
| 1405 | case Key::A: |
---|
| 1406 | mMoveLeft = state; |
---|
| 1407 | break; |
---|
| 1408 | |
---|
| 1409 | case Key::D: |
---|
| 1410 | mMoveRight = state; |
---|
| 1411 | break; |
---|
| 1412 | |
---|
| 1413 | case Key::S: |
---|
| 1414 | mMoveBck = state; |
---|
| 1415 | break; |
---|
| 1416 | |
---|
| 1417 | case Key::W: |
---|
| 1418 | mMoveFwd = state; |
---|
| 1419 | break; |
---|
| 1420 | |
---|
| 1421 | default: |
---|
| 1422 | break; |
---|
| 1423 | |
---|
| 1424 | } |
---|
| 1425 | |
---|
| 1426 | mProcessMovement = mMoveLeft || mMoveRight || mMoveFwd || mMoveBck; |
---|
| 1427 | |
---|
| 1428 | } |
---|