SO3Engine: SO3Engine/SO3SceneGraph/SO3Water.cpp Source File

00001 /*
00002 -----------------------------------------------------------------------------
00003 This source file is part of OpenSpace3D
00004 For the latest info, see http://www.openspace3d.com
00005 
00006 Copyright (c) 2010 I-maginer
00007 
00008 This program is free software; you can redistribute it and/or modify it under
00009 the terms of the GNU Lesser General Public License as published by the Free Software
00010 Foundation; either version 2 of the License, or (at your option) any later
00011 version.
00012 
00013 This program is distributed in the hope that it will be useful, but WITHOUT
00014 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
00015 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
00016 
00017 You should have received a copy of the GNU Lesser General Public License along with
00018 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
00019 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
00020 http://www.gnu.org/copyleft/lesser.txt
00021 
00022 You may alternatively use this source under the terms of a specific version of
00023 the OpenSpace3D Unrestricted License provided you have obtained such a license from
00024 I-maginer.
00025 -----------------------------------------------------------------------------
00026 */
00027 
00035 #include "SO3Scene.h"
00036 #include "SO3Water.h"
00037 #include "../SO3Renderer/SO3Viewport.h"
00038 #include "SO3Camera.h"
00039 #include "SO3Environment.h"
00040 #include "SO3Sun.h"
00041 
00042 namespace SO3
00043 {
00044 
00045 SWater::SWater(SEnvironment* parent, std::string waterName, SViewPort* targetViewport, SCamera* targetCamera) : SEnvironmentComponent(parent, waterName)
00046 {
00047   CommonConstructorsSequence(targetViewport, targetCamera);
00048   CreateInfinitePlaneGeometry();
00049   Initialise();
00050 }
00051 
00052 SWater::SWater(SEnvironment* parent, std::string waterName, SViewPort* targetViewport, SCamera* targetCamera, int planeSizeX, int planeSizeY) : SEnvironmentComponent(parent, waterName)
00053 {
00054   CommonConstructorsSequence(targetViewport, targetCamera);
00055   CreateFinitePlaneGeometry(planeSizeX, planeSizeY);
00056   Initialise();
00057 }
00058 
00059 SWater::SWater(SEnvironment* parent, std::string waterName, SViewPort* targetViewport, SCamera* targetCamera, float waterRadius) : SEnvironmentComponent(parent, waterName)
00060 {
00061   CommonConstructorsSequence(targetViewport, targetCamera);
00062   CreateRadialPlaneGeometry(waterRadius);
00063   Initialise();
00064 }
00065 
00066 SWater::SWater() : SEnvironmentComponent(0, "")
00067 {
00068   // Forbiden (private)
00069 }
00070 
00071 void SWater::CommonConstructorsSequence(SViewPort* targetViewport, SCamera* targetCamera)
00072 {
00073   assert(targetViewport != 0);
00074   parentScene = parentEnvironment->GetScene();
00075   renderingViewport = targetViewport;
00076   renderingCamera = targetCamera;
00077 
00078   // Create Hydrax object
00079   Ogre::Viewport* ogreViewport = const_cast<Ogre::Viewport*> (renderingViewport->GetOgreViewPortPointer());
00080   Ogre::Camera* ogreCamera = const_cast<Ogre::Camera*> (renderingCamera->GetOgreCameraPointer());
00081   hydraxManager = new Hydrax::Hydrax(parentScene->GetOgreScenePointer(), ogreCamera, ogreViewport);
00082 
00083   // Configure perlin noise
00084   perlinNoiseOptions.Octaves = 8;
00085         perlinNoiseOptions.Scale = 0.85f;
00086         perlinNoiseOptions.Falloff = 0.49f;
00087         perlinNoiseOptions.Animspeed = 1.4f;
00088         perlinNoiseOptions.Timemulti = 1.27f;
00089         perlinNoiseOptions.GPU_Strength = 2.0f;
00090         perlinNoiseOptions.GPU_LODParameters = Ogre::Vector3(0.5f, 50, 150000);
00091 
00092   // Configure fft noise
00093   fftNoiseOptions.Resolution = 128;
00094   fftNoiseOptions.PhysicalResolution = 32.0f;
00095   fftNoiseOptions.Scale = 0.25f;
00096   fftNoiseOptions.WindDirection = Ogre::Vector2(4,5);
00097   fftNoiseOptions.AnimationSpeed = 1;
00098   fftNoiseOptions.KwPower = 6.0f;
00099   fftNoiseOptions.Amplitude = 1.0f;
00100   fftNoiseOptions.GPU_Strength = 2.0f;
00101   fftNoiseOptions.GPU_LODParameters = Ogre::Vector3(0.5f, 50, 150000);
00102 
00103   // For the moment, only perlin noise is supported by SO3 (random noise).
00104   hydraxNoise = CreatePerlinNoise();
00105   hydraxGeometry = 0;
00106 
00107   // Create our components class instances (that do not enable the component!)
00108   sunComponent        = new WaterComponentSun(this);
00109   foamComponent       = new WaterComponentFoam(this);
00110   depthComponent      = new WaterComponentDepth(this);
00111   smoothComponent     = new WaterComponentSmooth(this);
00112   causticsComponent   = new WaterComponentCaustics(this);
00113   underwaterComponent = new WaterComponentUnderwater(this);
00114   godRaysComponent    = new WaterComponentGodRays(this);
00115 }
00116 
00117 SWater::~SWater()
00118 {
00119   if(hydraxManager->isCreated())
00120   {
00121     hydraxManager->getRttManager()->removeRttListener(this, false);
00122     hydraxManager->remove();
00123 
00124     // hydraxGeometry & hydraxNoise are deleted by hydraxManager->remove();
00125     hydraxGeometry = 0;
00126     hydraxNoise = 0;
00127   }
00128 
00129   SAFE_DELETE(sunComponent);
00130   SAFE_DELETE(foamComponent);
00131   SAFE_DELETE(depthComponent);
00132   SAFE_DELETE(smoothComponent);
00133   SAFE_DELETE(causticsComponent);
00134   SAFE_DELETE(underwaterComponent);
00135   SAFE_DELETE(godRaysComponent);
00136   SAFE_DELETE(hydraxManager);
00137   SAFE_DELETE(hydraxGeometry);
00138   SAFE_DELETE(hydraxNoise);
00139   SAFE_DELETE(hydraxManager);
00140 }
00141 
00142 void SWater::Initialise()
00143 {
00144   // Load main options
00145   hydraxManager->setPlanesError(0.1f);
00146   if(Ogre::Root::getSingleton().getRenderSystem()->getName() == "OpenGL Rendering Subsystem")
00147     hydraxManager->setShaderMode(Hydrax::MaterialManager::SM_GLSL);
00148   else
00149     hydraxManager->setShaderMode(Hydrax::MaterialManager::SM_HLSL);
00150 
00151   /*TESTS*/
00152         hydraxManager->setFullReflectionDistance(100000000.0f);
00153         /*hydraxManager->setGlobalTransparency(float GlobalTransparency"));
00154         hydraxManager->setNormalDistortion(float NormalDistortion"));
00155         */
00156   /*END TESTS*/
00157 
00158   // Configure water color
00159   baseColour = Ogre::ColourValue(0.025, .2, 0.35);
00160   RefreshWaterColourGradient();
00161 
00162   // Enabling all components by default
00163   sunComponent->SetEnabled(true);
00164   foamComponent->SetEnabled(true);
00165   depthComponent->SetEnabled(true);
00166   smoothComponent->SetEnabled(true);
00167   causticsComponent->SetEnabled(true);
00168   underwaterComponent->SetEnabled(true);
00169   // TODO HYDRAX_COMPONENT_UNDERWATER_REFLECTIONS
00170   godRaysComponent->SetEnabled(true);
00171 
00172         // Load components settings (defaults params from hydrax demo).
00173   sunComponent->SetParameters(Ogre::Vector3(0.0f, 10000.0f, 0.0f), 1.75f, 600.0f, Ogre::Vector3(1.0f, 0.9f, 0.6f));
00174   foamComponent->SetParameters(75000000.0f, 0.003f, 0.0f, 1.0f);
00175   depthComponent->SetParameters(10.0f, 10.0f);
00176   smoothComponent->SetPower(5.0f);
00177   causticsComponent->SetParameters(1350.0f, 10.5f, 10.0f);
00178   godRaysComponent->SetParameters(Ogre::Vector3(0.3f, 2.46f, 2.29f), 0.015f, 5.0f, 100, 0.03f, false);
00179 
00180         // Load rtt settings. Let Hydrax autodetect texture size as a default (window size is taken).
00181   // TODO, manage LOW/MEDIUM/HIGH parameters.
00182         hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_REFLECTION, Hydrax::Size(0, 0));
00183         hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_REFRACTION, Hydrax::Size(0, 0));
00184         hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_DEPTH, Hydrax::Size(0, 0));
00185         hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_DEPTH_REFLECTION, Hydrax::Size(0, 0));
00186         hydraxManager->getRttManager()->setTextureSize(Hydrax::RttManager::RTT_GPU_NORMAL_MAP, Hydrax::Size(0, 0));
00187 
00188   if(!hydraxManager->isCreated())
00189     hydraxManager->create();
00190 
00191   // Skyx/Hydrax synchro listener.
00192   hydraxManager->getRttManager()->addRttListener(this);
00193 }
00194 
00195 Hydrax::Hydrax* SWater::GetHydrax()
00196 {
00197   return hydraxManager;
00198 }
00199 
00200 SWater::WaterComponent* SWater::GetComponent(SWater::WaterComponentType componentType)
00201 {
00202   SWater::WaterComponent* component = 0;
00203   switch(componentType)
00204   {
00205   case SWater::SO3_WATER_COMPONENT_SUN:
00206     component = sunComponent;
00207     break;
00208   case SWater::SO3_WATER_COMPONENT_FOAM:
00209     component = foamComponent;
00210     break;
00211   case SWater::SO3_WATER_COMPONENT_DEPTH:
00212     component = depthComponent;
00213     break;
00214   case SWater::SO3_WATER_COMPONENT_SMOOTH:
00215     component = smoothComponent;
00216     break;
00217   case SWater::SO3_WATER_COMPONENT_CAUSTICS:
00218     component = causticsComponent;
00219     break;
00220   case SWater::SO3_WATER_COMPONENT_UNDERWATER:
00221     component = underwaterComponent;
00222     break;
00223   case SWater::SO3_WATER_COMPONENT_GODRAYS:
00224     component = godRaysComponent;
00225     break;
00226   default:
00227     OGRE_EXCEPT(Ogre::Exception::ERR_INVALIDPARAMS, "Invalid water component type requested!", "SWater::GetComponent");
00228     break;
00229   }
00230   return component;
00231 }
00232 
00233 SWater::WaterComponentSun* SWater::GetSun()
00234 {
00235   return sunComponent;
00236 }
00237 
00238 SWater::WaterComponentFoam* SWater::GetFoam()
00239 {
00240   return foamComponent;
00241 }
00242 
00243 SWater::WaterComponentDepth* SWater::GetDepth()
00244 {
00245   return depthComponent;
00246 }
00247 
00248 SWater::WaterComponentSmooth* SWater::GetSmooth()
00249 {
00250   return smoothComponent;
00251 }
00252 
00253 SWater::WaterComponentCaustics* SWater::GetCaustics()
00254 {
00255   return causticsComponent;
00256 }
00257 
00258 SWater::WaterComponentUnderwater* SWater::GetUnderwater()
00259 {
00260   return underwaterComponent;
00261 }
00262 
00263 SWater::WaterComponentGodRays* SWater::GetGodRays()
00264 {
00265   return godRaysComponent;
00266 }
00267 
00268 SWater::WaterGeometryType SWater::GetGeometryType()
00269 {
00270   return actualGeometryType;
00271 }
00272   
00273 void SWater::SetGeometryTypeInfinitePlane()
00274 {
00275   CreateInfinitePlaneGeometry();
00276 }
00277 
00278 void SWater::SetGeometryTypeFinitePlane(int planeSizeX, int planeSizeY)
00279 {
00280   CreateFinitePlaneGeometry(planeSizeX, planeSizeY);
00281 }
00282   
00283 void SWater::SetGeometryTypeRadialPlane(float waterRadius)
00284 {
00285   CreateRadialPlaneGeometry(waterRadius);
00286 }
00287 
00288 void SWater::CreateInfinitePlaneGeometry()
00289 {
00290   // Set up geometry options
00291   Hydrax::Module::ProjectedGrid::Options geometryOptions;
00292   geometryOptions.Strength = 3.5f;
00293   geometryOptions.Elevation = 1.0f; // It's very important to set a little value here, cause max tesselation of the water plane is reached when the camera is at least to this height.
00294 
00295   // Create geometry module
00296   Hydrax::Module::ProjectedGrid* newHydraxGeometry;
00297   newHydraxGeometry = new Hydrax::Module::ProjectedGrid(hydraxManager, 
00298                                                         hydraxNoise,
00299                                                         Ogre::Plane(Ogre::Vector3(0,1,0), Ogre::Vector3(0,0,0)),
00300                                                         Hydrax::MaterialManager::NM_VERTEX,
00301                                                                                                                     geometryOptions);
00302 
00303   // Hydrax can handle the destruction of the existing geometry module.
00304   hydraxManager->setModule(newHydraxGeometry, true);
00305   
00306   // Updating internal data.
00307   hydraxGeometry = newHydraxGeometry;
00308   actualGeometryType = SO3_WATER_GEOM_INFINITE_PLANE;
00309 }
00310 
00311 void SWater::CreateFinitePlaneGeometry(int planeSizeX, int planeSizeY)
00312 {
00313   // Set up geometry options
00314   Hydrax::Module::SimpleGrid::Options geometryOptions;
00315   geometryOptions.MeshSize = Hydrax::Size(planeSizeX, planeSizeY);
00316 
00317   // Create geometry module
00318   Hydrax::Module::SimpleGrid* newHydraxGeometry;
00319   newHydraxGeometry = new Hydrax::Module::SimpleGrid(hydraxManager,
00320                                                      hydraxNoise,
00321                                                      Hydrax::MaterialManager::NM_VERTEX,
00322                                                      geometryOptions);
00323 
00324   // Hydrax can handle the destruction of the existing geometry module.
00325   hydraxManager->setModule(newHydraxGeometry, true);
00326   
00327   // Updating internal data.
00328   hydraxGeometry = newHydraxGeometry;
00329   actualGeometryType = SO3_WATER_GEOM_FINITE_PLANE;
00330 }
00331 
00332 void SWater::CreateRadialPlaneGeometry(float waterRadius)
00333 {
00334   // Set up geometry options
00335   Hydrax::Module::RadialGrid::Options geometryOptions;
00336   geometryOptions.Radius = waterRadius;
00337 
00338   // Create geometry module
00339   Hydrax::Module::RadialGrid* newHydraxGeometry;
00340   newHydraxGeometry = new Hydrax::Module::RadialGrid(hydraxManager,
00341                                                      hydraxNoise,
00342                                                      Hydrax::MaterialManager::NM_VERTEX,
00343                                                      geometryOptions);
00344 
00345   // Hydrax can handle the destruction of the existing geometry module.
00346   hydraxManager->setModule(newHydraxGeometry, true);
00347   
00348   // Updating internal data.
00349   hydraxGeometry = newHydraxGeometry;
00350   actualGeometryType = SO3_WATER_GEOM_RADIAL;
00351 }
00352 
00353 void SWater::RefreshWaterColourGradient()
00354 {
00355   // Alpha is not managed by Hydrax, which only use a Ogre::Vector3 for rgb values, so do not care about alpha that will be less than 1 after those multiplications.
00356   waterColourGradient.Clear();
00357   waterColourGradient.AddColourFrame(1.0,  baseColour);
00358   waterColourGradient.AddColourFrame(0.8,  baseColour * 0.75);
00359   waterColourGradient.AddColourFrame(0.6,  baseColour * 0.625);
00360   waterColourGradient.AddColourFrame(0.5,  baseColour * 0.5);
00361   waterColourGradient.AddColourFrame(0.45, baseColour * 0.25);
00362   waterColourGradient.AddColourFrame(0.0,  baseColour * 0.0625);
00363 }
00364 
00365 /**********************************/
00366 /* Base component class.          */
00367 /* Do not use directly, must be   */
00368 /* derivated.                     */
00369 /**********************************/
00370 SWater::WaterComponent::WaterComponent(SWater* parentWaterInstance, SWater::WaterComponentType component, Hydrax::HydraxComponent hydraxComponent) : componentType(component),
00371                                                                                                                                                      hydraxComponentType(hydraxComponent)
00372 {
00373   parentWater = parentWaterInstance;
00374   hydraxManager = parentWater->GetHydrax();
00375   waterComponentEnable = false;
00376 }
00377 
00378 SWater::WaterComponent::WaterComponent() : componentType(SWater::SO3_WATER_COMPONENT_NONE),
00379                                            hydraxComponentType(Hydrax::HYDRAX_COMPONENTS_NONE)
00380 {
00381   // Forbiden constructor (private).
00382   hydraxManager = 0;
00383   parentWater = 0;
00384   waterComponentEnable = false;
00385 }
00386 
00387 SWater::WaterComponent::~WaterComponent()
00388 {
00389   SetEnabled(false);
00390   hydraxManager = 0;
00391   parentWater = 0;
00392 }
00393 
00394 bool SWater::WaterComponent::GetEnabled()
00395 {
00396   return waterComponentEnable;
00397 }
00398 
00399 void SWater::WaterComponent::SetEnabled(bool enable)
00400 {
00401   if(waterComponentEnable != enable)
00402   {
00403     if(enable)
00404       hydraxManager->setComponents(static_cast<Hydrax::HydraxComponent> (hydraxManager->getComponents() | hydraxComponentType));
00405     else
00406       hydraxManager->setComponents(static_cast<Hydrax::HydraxComponent> (hydraxManager->getComponents() ^ hydraxComponentType));
00407 
00408     // The hydrax component could be deactivated internally by our SWater component, but we need to keep information about our SWater component state.
00409     waterComponentEnable = enable;
00410   }
00411 }
00412 
00413 SWater::WaterComponentType SWater::WaterComponent::GetType()
00414 {
00415   return componentType;
00416 }
00417 
00418 /**********************************/
00419 /* Sun component functions        */
00420 /**********************************/
00421 SWater::WaterComponentSun::WaterComponentSun(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_SUN, Hydrax::HYDRAX_COMPONENT_SUN) 
00422 {
00423   horizonPlane = Ogre::Plane(Ogre::Vector3::UNIT_Y, 0);
00424 }
00425 
00426 SWater::WaterComponentSun::WaterComponentSun() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
00427 {
00428   // Forbiden constructor (private).
00429 }
00430 
00431 void SWater::WaterComponentSun::SetParameters(Ogre::Vector3 position, float strength, float area, Ogre::Vector3 color)
00432 {
00433   hydraxManager->setSunPosition(position);
00434         hydraxManager->setSunStrength(strength);
00435         hydraxManager->setSunArea(area);
00436         hydraxManager->setSunColor(color);
00437 }
00438 
00439 Ogre::Vector3 SWater::WaterComponentSun::GetPosition()
00440 {
00441   return hydraxManager->getSunPosition();
00442 }
00443 
00444 void SWater::WaterComponentSun::SetPosition(Ogre::Vector3 position)
00445 {
00446   hydraxManager->setSunPosition(position);
00447 }
00448 
00449 float SWater::WaterComponentSun::GetStrength()
00450 {
00451         return hydraxManager->getSunStrength();
00452 }
00453 
00454 void SWater::WaterComponentSun::SetStrength(float strength)
00455 {
00456   hydraxManager->setSunStrength(strength);
00457 }
00458 
00459 float SWater::WaterComponentSun::GetArea()
00460 {
00461   return hydraxManager->getSunArea();
00462 }
00463 
00464 void SWater::WaterComponentSun::SetArea(float area)
00465 {
00466   hydraxManager->setSunArea(area);
00467 }
00468 
00469 Ogre::ColourValue SWater::WaterComponentSun::GetColor()
00470 {
00471   Ogre::Vector3 sunColour = hydraxManager->getSunColor();
00472   return Ogre::ColourValue(sunColour.x, sunColour.y, sunColour.z);
00473 }
00474 
00475 void SWater::WaterComponentSun::SetColor(Ogre::ColourValue color)
00476 {
00477   Ogre::Vector3 sunColour(color.r, color.g, color.b);
00478   hydraxManager->setSunColor(sunColour);
00479 }
00480 
00481 void SWater::WaterComponentSun::Update(Ogre::Real updateTime)
00482 {
00483   // Get the hydrax internal component state
00484   bool hydraxComponentState = hydraxManager->isComponent(hydraxComponentType);
00485 
00486   // Get sun light direction
00487   Ogre::Vector3 sunLightDirecton = parentWater->GetEnvironment()->GetSun()->GetLightDirection();
00488 
00489   /*// Check if the sun is above or below the horizon
00490   Ogre::Plane::Side sunSide = horizonPlane.getSide(-sunLightDirecton);
00491   if(sunSide == Ogre::Plane::POSITIVE_SIDE)
00492   {
00493     if(!hydraxComponentState)
00494     {
00495       // Enable this hydrax component when sun is above horizon.
00496       hydraxManager->setComponents(static_cast<Hydrax::HydraxComponent> (hydraxManager->getComponents() | hydraxComponentType));
00497       hydraxComponentState = true;
00498     }
00499   }
00500   else
00501   {
00502     if(sunSide == Ogre::Plane::NEGATIVE_SIDE)
00503     {
00504       if(hydraxComponentState)
00505       {
00506         // disable this hydrax component when sun is above horizon.
00507         hydraxManager->setComponents(static_cast<Hydrax::HydraxComponent> (hydraxManager->getComponents() ^ hydraxComponentType));
00508         hydraxComponentState = false;
00509       }
00510     }
00511   }*/
00512 
00513   if(hydraxComponentState == true)
00514   {
00515     // Handle infinite camera clip plane.
00516     float cameraFarClip = hydraxManager->getCamera()->getFarClipDistance();
00517     if((cameraFarClip == 0) || (cameraFarClip > 9999.0f))
00518       cameraFarClip = 9999.0f;
00519 
00520     // Update sun position 
00521     hydraxManager->setSunPosition(hydraxManager->getCamera()->getDerivedPosition() - (sunLightDirecton * cameraFarClip));
00522   }
00523 }
00524 
00525 /**********************************/
00526 /* Foam component functions       */
00527 /**********************************/
00528 SWater::WaterComponentFoam::WaterComponentFoam(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_FOAM, Hydrax::HYDRAX_COMPONENT_FOAM) 
00529 {
00530 }
00531 
00532 SWater::WaterComponentFoam::WaterComponentFoam() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
00533 {
00534   // Forbiden constructor (private).
00535 }
00536 
00537 void SWater::WaterComponentFoam::SetParameters(float maxDistance, float scale, float start, float transparency)
00538 {
00539         hydraxManager->setFoamMaxDistance(maxDistance);
00540         hydraxManager->setFoamScale(scale);
00541         hydraxManager->setFoamStart(start);
00542         hydraxManager->setFoamTransparency(transparency);
00543 }
00544 
00545 float SWater::WaterComponentFoam::GetMaxDistance()
00546 {
00547   return hydraxManager->getFoamMaxDistance();
00548 }
00549 
00550 void SWater::WaterComponentFoam::SetMaxDistance(float maxDistance)
00551 {
00552   hydraxManager->setFoamMaxDistance(maxDistance);
00553 }
00554 
00555 float SWater::WaterComponentFoam::GetScale()
00556 {
00557   return hydraxManager->getFoamScale();
00558 }
00559 
00560 void SWater::WaterComponentFoam::SetScale(float scale)
00561 {
00562   hydraxManager->setFoamScale(scale);
00563 }
00564 
00565 float SWater::WaterComponentFoam::GetStart()
00566 {
00567   return hydraxManager->getFoamStart();
00568 }
00569 
00570 void SWater::WaterComponentFoam::SetStart(float start)
00571 {
00572   hydraxManager->setFoamStart(start);
00573 }
00574 
00575 float SWater::WaterComponentFoam::GetTransparency()
00576 {
00577   return hydraxManager->getFoamTransparency();
00578 }
00579 
00580 void SWater::WaterComponentFoam::SetTransparency(float transparency)
00581 {
00582         hydraxManager->setFoamTransparency(transparency);
00583 }
00584 
00585 void SWater::WaterComponentFoam::Update(Ogre::Real updateTime)
00586 {
00588 }
00589 
00590 /**********************************/
00591 /* Depth component functions      */
00592 /**********************************/
00593 SWater::WaterComponentDepth::WaterComponentDepth(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_DEPTH, Hydrax::HYDRAX_COMPONENT_DEPTH) 
00594 {
00595 }
00596 
00597 SWater::WaterComponentDepth::WaterComponentDepth() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
00598 {
00599   // Forbiden constructor (private).
00600 }
00601 
00602 void SWater::WaterComponentDepth::SetParameters(float depthLimit, float distortionLimit)
00603 {
00604   hydraxManager->setDepthLimit(depthLimit);
00605   hydraxManager->setDistLimit(distortionLimit);
00606 }
00607 
00608 float SWater::WaterComponentDepth::GetDepthLimit()
00609 {
00610   return hydraxManager->getDepthLimit();
00611 }
00612 
00613 void SWater::WaterComponentDepth::SetDepthLimit(float depthLimit)
00614 {
00615         hydraxManager->setDepthLimit(depthLimit);
00616 }
00617 
00618 void SWater::WaterComponentDepth::SetDistortionLimit(float distortionLimit)
00619 {
00620   hydraxManager->setDistLimit(distortionLimit);
00621 }
00622 
00623 float SWater::WaterComponentDepth::GetDistortionLimit()
00624 {
00625   return hydraxManager->getDistLimit();
00626 }
00627 
00628 void SWater::WaterComponentDepth::Update(Ogre::Real updateTime)
00629 {
00630   // TODO Depth should vary a little depending day or night.
00631 }
00632 
00633 /**********************************/
00634 /* Smoothing component functions  */
00635 /**********************************/
00636 SWater::WaterComponentSmooth::WaterComponentSmooth(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_SMOOTH, Hydrax::HYDRAX_COMPONENT_SMOOTH) 
00637 {
00638 }
00639 
00640 SWater::WaterComponentSmooth::WaterComponentSmooth() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
00641 {
00642   // Forbiden constructor (private).
00643 }
00644 
00645 float SWater::WaterComponentSmooth::GetPower()
00646 {
00647   return hydraxManager->getSmoothPower();
00648 }
00649 
00650 void SWater::WaterComponentSmooth::SetPower(float smoothPower)
00651 {
00652         hydraxManager->setSmoothPower(smoothPower);
00653 }
00654 
00655 void SWater::WaterComponentSmooth::Update(Ogre::Real updateTime)
00656 {
00657   // Nothing to do
00658 }
00659 
00660 /**********************************/
00661 /* Caustics component functions   */
00662 /**********************************/
00663 SWater::WaterComponentCaustics::WaterComponentCaustics(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_CAUSTICS, Hydrax::HYDRAX_COMPONENT_CAUSTICS) 
00664 {
00665 }
00666 
00667 SWater::WaterComponentCaustics::WaterComponentCaustics() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
00668 {
00669   // Forbiden constructor (private).
00670 }
00671 
00672 void SWater::WaterComponentCaustics::SetParameters(float scale, float power, float end)
00673 {
00674         hydraxManager->setCausticsScale(scale);
00675         hydraxManager->setCausticsPower(power);
00676         hydraxManager->setCausticsEnd(end);
00677 }
00678 
00679 float SWater::WaterComponentCaustics::GetScale()
00680 {
00681   return hydraxManager->getCausticsScale();
00682 }
00683 
00684 void SWater::WaterComponentCaustics::SetScale(float scale)
00685 {
00686         hydraxManager->setCausticsScale(scale);
00687 }
00688 
00689 float SWater::WaterComponentCaustics::GetPower()
00690 {
00691   return hydraxManager->getCausticsPower();
00692 }
00693 
00694 void SWater::WaterComponentCaustics::SetPower(float power)
00695 {
00696         hydraxManager->setCausticsPower(power);
00697 }
00698 
00699 float SWater::WaterComponentCaustics::GetEnd()
00700 {
00701   return hydraxManager->getCausticsEnd();
00702 }
00703 
00704 void SWater::WaterComponentCaustics::SetEnd(float end)
00705 {
00706                 hydraxManager->setCausticsEnd(end);
00707 }
00708 
00709 void SWater::WaterComponentCaustics::Update(Ogre::Real updateTime)
00710 {
00711   // TODO Darker caustics (lower intensity) at night.
00712 }
00713 
00714 /**********************************/
00715 /* Underwater component functions */
00716 /**********************************/
00717 SWater::WaterComponentUnderwater::WaterComponentUnderwater(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_UNDERWATER, Hydrax::HYDRAX_COMPONENT_UNDERWATER) 
00718 {
00719 }
00720 
00721 SWater::WaterComponentUnderwater::WaterComponentUnderwater() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
00722 {
00723   // Forbiden constructor (private).
00724 }
00725 
00726 void SWater::WaterComponentUnderwater::Update(Ogre::Real updateTime)
00727 {
00728   // Nothing to do.
00729 }
00730 
00731 /**********************************/
00732 /* God rays component functions   */
00733 /**********************************/
00734 SWater::WaterComponentGodRays::WaterComponentGodRays(SWater* parentWaterInstance) : SWater::WaterComponent(parentWaterInstance, SWater::SO3_WATER_COMPONENT_GODRAYS, Hydrax::HYDRAX_COMPONENT_UNDERWATER_GODRAYS) 
00735 {
00736 }
00737 
00738 SWater::WaterComponentGodRays::WaterComponentGodRays() : SWater::WaterComponent(0, SWater::SO3_WATER_COMPONENT_NONE, Hydrax::HYDRAX_COMPONENTS_NONE)
00739 {
00740   // Forbiden constructor (private).
00741 }
00742 
00743 void SWater::WaterComponentGodRays::SetParameters(Ogre::Vector3 exposure, float intensity, float speed, int numberOfRays, float raysSize, bool raysIntersections)
00744 {
00745         hydraxManager->setGodRaysExposure(exposure);
00746         hydraxManager->setGodRaysIntensity(intensity);
00747         hydraxManager->getGodRaysManager()->setSimulationSpeed(speed);
00748         hydraxManager->getGodRaysManager()->setNumberOfRays(numberOfRays);
00749         hydraxManager->getGodRaysManager()->setRaysSize(raysSize);
00750         hydraxManager->getGodRaysManager()->setObjectIntersectionsEnabled(raysIntersections);
00751 }
00752 
00753 Ogre::Vector3   SWater::WaterComponentGodRays::GetExposure()
00754 {
00755   return hydraxManager->getGodRaysExposure();
00756 }
00757 
00758 void SWater::WaterComponentGodRays::SetExposure(Ogre::Vector3 exposure)
00759 {
00760   hydraxManager->setGodRaysExposure(exposure);
00761 }
00762 
00763 float SWater::WaterComponentGodRays::GetIntensity()
00764 {
00765   return hydraxManager->getGodRaysIntensity();
00766 }
00767 
00768 void SWater::WaterComponentGodRays::SetIntensity(float intensity)
00769 {
00770   hydraxManager->setGodRaysIntensity(intensity);
00771 }
00772 
00773 float SWater::WaterComponentGodRays::GetSpeed()
00774 {
00775   return hydraxManager->getGodRaysManager()->getSimulationSpeed();
00776 }
00777 
00778 void SWater::WaterComponentGodRays::SetSpeed(float speed)
00779 {
00780   hydraxManager->getGodRaysManager()->setSimulationSpeed(speed);
00781 }
00782 
00783 int SWater::WaterComponentGodRays::GetNumberOfRays()
00784 {
00785   return hydraxManager->getGodRaysManager()->getNumberOfRays();
00786 }
00787 
00788 void SWater::WaterComponentGodRays::SetNumberOfRays(int numberOfRays)
00789 {
00790   hydraxManager->getGodRaysManager()->setNumberOfRays(numberOfRays);
00791 }
00792 
00793 float SWater::WaterComponentGodRays::GetRaysSize()
00794 {
00795   return hydraxManager->getGodRaysManager()->getRaysSize();
00796 }
00797 
00798 void SWater::WaterComponentGodRays::SetRaysSize(float raysSize)
00799 {
00800   hydraxManager->getGodRaysManager()->setRaysSize(raysSize);
00801 }
00802 
00803 bool SWater::WaterComponentGodRays::GetRaysIntersectionEnable()
00804 {
00805   return hydraxManager->getGodRaysManager()->areObjectsIntersectionsEnabled();
00806 }
00807 
00808 void SWater::WaterComponentGodRays::SetRaysIntersectionEnable(bool raysIntersections)
00809 {
00810   hydraxManager->getGodRaysManager()->setObjectIntersectionsEnabled(raysIntersections);
00811 }
00812 
00813 void SWater::WaterComponentGodRays::Update(Ogre::Real updateTime)
00814 {
00815   // Nothing to do, automatically disable when hydrax sun component is deactivated, so no need to disable it when sun is below horizon.
00816 }
00817 
00818 void SWater::SetWindSpeed(float newWindSpeed)
00819 {
00820   // Change wave rendering
00821   /*if(newWindSpeed > 0.0f)
00822   {
00823     fftNoiseOptions.Amplitude = ?;
00824     fftNoiseOptions.AnimationSpeed = ?
00825   }*/
00826 
00827   // Change hydrax noise module if necessary
00828   if((newWindSpeed == 0.0f) && (hydraxNoise->getName() != "Perlin"))
00829   {
00830     // Old Hydrax noise module is automatically deleted.
00831     Hydrax::Noise::Noise* newHydraxNoise = CreatePerlinNoise();
00832     hydraxGeometry->setNoise(newHydraxNoise);
00833     hydraxNoise = newHydraxNoise;
00834   }
00835   else
00836   {
00837     if((newWindSpeed > 0.0f) && (hydraxNoise->getName() != "FFT"))
00838     {
00839       Hydrax::Noise::Noise* newHydraxNoise = CreateFftNoise();
00840       hydraxGeometry->setNoise(newHydraxNoise);
00841       hydraxNoise = newHydraxNoise;
00842     }
00843     else
00844     {
00845       //static_cast<Hydrax::Noise::FFT*> (hydraxNoise)->setOptions(hydraxNoiseOptions);
00846     }
00847   }
00848 }
00849 
00850 void SWater::SetWindDirection(Ogre::Vector3 newWindDirection)
00851 {
00852   fftNoiseOptions.WindDirection = Ogre::Vector2(newWindDirection.x, newWindDirection.z);
00853   //fftNoiseOptions.Amplitude  ? We 'may' use windDirection.y to modify amplitude...
00854 
00855   if (hydraxNoise->getName() == "FFT")
00856     (static_cast<Hydrax::Noise::FFT*> (hydraxNoise))->setOptions(fftNoiseOptions);
00857 }
00858 
00859 void SWater::Update(Ogre::Real updateTime)
00860 {
00861   // Update water color
00862   Ogre::ColourValue ogreColourValue = waterColourGradient.GetColour(((1.0f - parentEnvironment->GetSun()->GetLightDirection().y) / 2));
00863   hydraxManager->setWaterColor(Ogre::Vector3(ogreColourValue.r, ogreColourValue.g, ogreColourValue.b));
00864 
00865   // Update all active water components. Order is important!!!
00866   if(sunComponent->GetEnabled())
00867     sunComponent->Update(updateTime);
00868 
00869   if(foamComponent->GetEnabled())
00870     foamComponent->Update(updateTime);
00871 
00872   if(depthComponent->GetEnabled())
00873     depthComponent->Update(updateTime);
00874 
00875   if(smoothComponent->GetEnabled())
00876     smoothComponent->Update(updateTime);
00877 
00878   if(causticsComponent->GetEnabled())
00879     causticsComponent->Update(updateTime);
00880 
00881   if(underwaterComponent->GetEnabled())
00882     underwaterComponent->Update(updateTime);
00883   
00884   if(godRaysComponent->GetEnabled())
00885     godRaysComponent->Update(updateTime);
00886 }
00887 
00888 const Ogre::Vector3& SWater::GetPosition() const
00889 {
00890   return hydraxManager->getPosition();
00891 }
00892 
00893 void SWater::SetPosition(const Ogre::Vector3& newSeaLevel)
00894 {
00895   hydraxManager->setPosition(newSeaLevel);
00896 }
00897 
00898 Ogre::ColourValue SWater::GetColor()
00899 {
00900   return baseColour;
00901 }
00902 
00903 void SWater::SetColor(Ogre::ColourValue color)
00904 {
00905   baseColour = color;
00906   RefreshWaterColourGradient();
00907 }
00908 
00909 float SWater::GetAnimationSpeed()
00910 {
00911   return hydraxManager->getTimeMultiplier();
00912 }
00913 
00914 void SWater::SetAnimationSpeed(float animationSpeed)
00915 {
00916   hydraxManager->setTimeMultiplier(animationSpeed);
00917 }
00918 
00919 Hydrax::Noise::Noise* SWater::CreatePerlinNoise()
00920 {
00921   return new Hydrax::Noise::Perlin(perlinNoiseOptions);
00922 }
00923 
00924 Hydrax::Noise::Noise* SWater::CreateFftNoise()
00925 {
00926   return new Hydrax::Noise::FFT(fftNoiseOptions);
00927 }
00928 
00929 void SWater::preRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt)
00930 {
00931   SSky* sky = parentEnvironment->GetSky();
00932   if(sky)
00933   {
00934     SkyX::SkyX* skyxManager = sky->GetSkyX();
00935     assert(skyxManager != 0);
00936 
00937     switch (Rtt)
00938     {
00939             case Hydrax::RttManager::RTT_REFLECTION:
00940             {
00941                     // No stars in the reflection map
00942                     skyxManager->setStarfieldEnabled(false);
00943             }
00944             break;
00945 
00946             case Hydrax::RttManager::RTT_REFRACTION:
00947             {
00948             }
00949             break;
00950 
00951             case Hydrax::RttManager::RTT_DEPTH:
00952       case Hydrax::RttManager::RTT_DEPTH_REFLECTION:
00953             {
00954                     // Hide SkyX components in depth maps
00955                     skyxManager->getMeshManager()->getEntity()->setVisible(false);
00956                     skyxManager->getMoonManager()->getMoonBillboard()->setVisible(false);
00957             }
00958             break;
00959     }
00960   }
00961 }
00962 
00963 void SWater::postRenderTargetUpdate(const Hydrax::RttManager::RttType& Rtt)
00964 {
00965   SSky* sky = parentEnvironment->GetSky();
00966   if(sky)
00967   {
00968     SkyX::SkyX* skyxManager = sky->GetSkyX();
00969     assert(skyxManager != 0);
00970 
00971           switch (Rtt)
00972           {
00973                   case Hydrax::RttManager::RTT_REFLECTION:
00974                   {
00975                           skyxManager->setStarfieldEnabled(true);
00976                   }
00977                   break;
00978 
00979                   case Hydrax::RttManager::RTT_REFRACTION:
00980                   {
00981                   }
00982                   break;
00983 
00984                   case Hydrax::RttManager::RTT_DEPTH:
00985       case Hydrax::RttManager::RTT_DEPTH_REFLECTION:
00986                   {
00987                           skyxManager->getMeshManager()->getEntity()->setVisible(true);
00988                           skyxManager->getMoonManager()->getMoonBillboard()->setVisible(true);
00989                   }
00990                   break;
00991           }
00992   }
00993 }
00994 
00995 }