SO3Environment.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3SceneGraph/SO3Environment.h"
#include "SO3SceneGraph/SO3Sun.h"
#include "SO3SceneGraph/SO3Moon.h"
#include "SO3SceneGraph/SO3Camera.h"
#include "SO3Renderer/SO3ViewPort.h"
#include "SO3Utils/SO3UniversalClock.h"
#include "SO3Utils/SO3DateTime.h"
 
namespace SO3
{
 
SEnvironment::SEnvironment(SScene* parent, const std::string& environmentName) : SData(environmentName)
{
  // Init ptr
  scene = parent;
  water = 0;
  sky = 0;
  sun = 0;
  moon = 0;
  universalClock = 0;
 
  // Init vars
  paused = false;
  enabled = false;
  skyEnabled = false;
  waterEnabled = false;
 
  // Init position
  observerLatitude  = 45.0f;
  observerLongitude = 0.0f;
 
  // Init wind & humidity
  windSpeed = 1.0f;
  windDirection = Ogre::Vector2::UNIT_X;
  humidityFactor = 25.0f;
 
  // Time/date calculation
  universalClock = new SUniversalClock();
  universalClock->SetGregorianDateTime(2000, 1, 1, 12, 0, 0); // Mid-day
  // universalClock->SetGregorianDateTime(2000, 1, 1,  0,  0, 0); // Following tests are for E0 N45 coordinates.
  // universalClock->SetGregorianDateTime(2000, 1, 1,  7, 38, 0); // Testing sunrise
  // universalClock->SetGregorianDateTime(2000, 1, 1, 12,  4, 0); // Testing sun transit
  // universalClock->SetGregorianDateTime(2000, 1, 1, 16, 29, 0); // Testing sunset
  // universalClock->SetGregorianDateTime(2000, 1, 1, 3, 0, 0); // Testing moonrise (approx)
  // universalClock->SetGregorianDateTime(2000, 1, 1,  0, 16, 0); // Testing moon transit
  // universalClock->SetGregorianDateTime(2000, 1, 1,  8, 13, 0); // Testing moonset
  // universalClock->SetGregorianDateTime(2000, 1, 1,  2, 10, 0);
 
  // Sun/moon position & lighting
  sun = new SSun(this, "SO3/Internal/Environment/"+ name +"/Sun");
  moon = new SMoon(this, "SO3/Internal/Environment/"+ name +"/Moon");
 
  sun->UpdateShadowFarDistance(scene->GetOgreScenePointer()->getShadowFarDistance());
  sun->UpdateShadowFarClipDistance(scene->GetOgreScenePointer()->getShadowDirectionalLightExtrusionDistance());
   
  moon->UpdateShadowFarDistance(scene->GetOgreScenePointer()->getShadowFarDistance());
  moon->UpdateShadowFarClipDistance(scene->GetOgreScenePointer()->getShadowDirectionalLightExtrusionDistance());
 
  // Sky object
  sky = new SSky(this, "SO3/Internal/Environment/"+ name +"/Sky");
 
  // Water object
  water = new SWater(this, "SO3/Internal/Environment/"+ name +"/Water");
 
  // Add frame listener
  Ogre::Root::getSingleton().addFrameListener(this);
 
  //SetTimeSpeedFactor(3600); // 1 sec = 1 hour
  //SetTimeSpeedFactor(60);     // 1 sec = 1 minute
  SetTimeSpeedFactor(1);    // realtime
}
 
SEnvironment::SEnvironment() : SData("")
{
  // Forbiden (private)
}
 
SEnvironment::~SEnvironment()
{
  // Removing frame listener
  Ogre::Root::getSingleton().removeFrameListener(this);
 
  UnregisterAllViewports();
  SO3_SAFE_DELETE(water);
  SO3_SAFE_DELETE(sky);
  SO3_SAFE_DELETE(moon);
  SO3_SAFE_DELETE(sun);
  SO3_SAFE_DELETE(universalClock);
}
 
SScene* SEnvironment::GetScene()
{
  return scene;
}
 
void SEnvironment::RegisterViewport(SViewPort* targetViewport)
{
  ViewportList::iterator iSearchedViewport = viewportList.find(targetViewport);
  if(iSearchedViewport == viewportList.end())
  {
    // Add to the viewports list
    viewportList.insert(targetViewport);
 
    // Register viewport in sub-components.
    if(sky)
      sky->RegisterViewport(targetViewport);
    if(water)
      water->RegisterViewport(targetViewport);
 
    // Check if the viewport's parent render target is allready registered.
    Ogre::RenderTarget* parentRenderTarger = targetViewport->GetOgreViewPortPointer()->getTarget();
    RenderTargetList::iterator searchedRenderTarget = mRenderTargetList.find(parentRenderTarger);
    if(searchedRenderTarget == mRenderTargetList.end())
    {
      // Not found, register SEnvironment as a listener on it, and add it to the list.
      parentRenderTarger->addListener(this);
      mRenderTargetList.insert(RenderTargetList::value_type(parentRenderTarger, 1));
    }
    else
    {
      // Found, increase the reference count.
      mRenderTargetList[parentRenderTarger] += 1;
    }
  }
  else
    OGRE_EXCEPT(Ogre::Exception::ERR_DUPLICATE_ITEM, "The viewport already exist in the list of associated viewports!", "SEnvironment::RegisterViewport");
}
 
void SEnvironment::UnregisterViewport(SViewPort* targetViewport)
{
  ViewportList::iterator iSearchedViewport = viewportList.find(targetViewport);
  if(iSearchedViewport != viewportList.end())
  {
    // Check if we need to unregister SkyX from the viewport's parent rendertarget.
    Ogre::RenderTarget* parentRenderTarger = targetViewport->GetOgreViewPortPointer()->getTarget();
    mRenderTargetList[parentRenderTarger] -= 1;
    if(mRenderTargetList[parentRenderTarger] == 0)
    {
      parentRenderTarger->removeListener(this);
      mRenderTargetList.erase(parentRenderTarger);
    }
 
    // Unregister viewport from sub-components.
    if(water)
      water->UnregisterViewport(targetViewport);
    if(sky)
      sky->UnregisterViewport(targetViewport);
 
    // Remove from the viewport list
    viewportList.erase(targetViewport);
  }
 
  //$BB do not send an exception, now all viewports are unregistered by scene
  //else
  //  OGRE_EXCEPT(Ogre::Exception::ERR_ITEM_NOT_FOUND, "Cannot find the viewport in the list of associated viewports!", "SEnvironment::UnregisterViewport");
}
 
void SEnvironment::UnregisterCamera(Ogre::Camera* cam)
{
  // Unregister viewport from sub-components.
  if(water)
    water->UnregisterCamera(cam);
  if(sky)
    sky->UnregisterCamera(cam);
}
 
bool SEnvironment::IsRegisteredViewport(SViewPort* targetViewport)
{
  ViewportList::iterator iSearchedViewport = viewportList.find(targetViewport);
  if(iSearchedViewport != viewportList.end())
    return true;
  else
    return false;
}
 
bool SEnvironment::IsRegisteredViewport(Ogre::Viewport* targetViewport)
{
  ViewportList::iterator iViewportList = viewportList.begin();
  while(iViewportList != viewportList.end())
  {
    if ((*iViewportList)->GetOgreViewPortPointer() == targetViewport)
      return true;
 
    iViewportList++;
  }
  return false;
}
 
void SEnvironment::UnregisterAllViewports()
{
  ViewportList viewportListCopy = viewportList;
  ViewportList::iterator iViewportList = viewportListCopy.begin();
  while(iViewportList != viewportListCopy.end())
  {
    UnregisterViewport(*iViewportList);
    iViewportList++;
  }
}
 
SEnvironment::ViewportList SEnvironment::GetRegisteredViewports()
{
  return viewportList;
}
 
SUniversalClock* SEnvironment::GetUniversalClock()
{
  return universalClock;
}
 
SWater* SEnvironment::GetWater()
{
  return water;
}
 
SSky* SEnvironment::GetSky()
{
  return sky;
}
 
SSun* SEnvironment::GetSun()
{
  return sun;
}
 
SMoon* SEnvironment::GetMoon()
{
  return moon;
}
 
bool SEnvironment::GetEnable()
{
  return enabled;
}
 
void SEnvironment::SetEnable(const bool& enableEnvironment)
{
  enabled = enableEnvironment;
  if(enabled)
  {
    if(water)
      water->SetEnable(waterEnabled);
    if(sky)
      sky->SetEnable(skyEnabled);
    if(sun)
      sun->SetEnable(true);
    if(moon)
      moon->SetEnable(true);
  }
  else
  {
    if(water)
      water->SetEnable(false);
    if(sky)
      sky->SetEnable(false);
    if(sun)
      sun->SetEnable(false);
    if(moon)
      moon->SetEnable(false);
  }
}
 
bool SEnvironment::GetWaterEnable()
{
  return waterEnabled;
}
 
void SEnvironment::SetWaterEnable(const bool& enableWater)
{
  waterEnabled = enableWater;
  if(enabled)
    if(water)
      water->SetEnable(waterEnabled);
}
 
bool SEnvironment::GetSkyEnable()
{
  return skyEnabled;
}
 
void SEnvironment::SetSkyEnable(const bool& enableSky)
{
  skyEnabled = enableSky;
  if(enabled)
    if(sky)
      sky->SetEnable(skyEnabled);
}
 
float SEnvironment::GetWindSpeed()
{
  return windSpeed;
}
 
void SEnvironment::SetWindSpeed(const float& newWindSpeed)
{
  windSpeed = newWindSpeed;
}
 
Ogre::Vector2 SEnvironment::GetWindDirection()
{
  return windDirection;
}
 
void SEnvironment::SetWindDirection(const Ogre::Vector2& newWindDirection)
{
  windDirection = newWindDirection.normalisedCopy();
}
 
float SEnvironment::GetHumidity()
{
  return humidityFactor;
}
 
void SEnvironment::SetHumidity(const float& newHumidity)
{
  // Check values
  humidityFactor = newHumidity;
  if(newHumidity < 0.0f)
    humidityFactor = 0.0f;
  if(newHumidity > 100.0f)
    humidityFactor = 100.0f;
}
 
float SEnvironment::GetTimeSpeedFactor()
{
  if(universalClock)
    return universalClock->GetTimeScale();
  else
    return 0.0f;
}
 
void SEnvironment::SetTimeSpeedFactor(const float& newTimeSpeedFactor)
{
  if(universalClock)
    universalClock->SetTimeScale(newTimeSpeedFactor);
}
 
bool SEnvironment::GetPaused()
{
  return paused;
}
 
void SEnvironment::SetPaused(const bool& pauseSimulation)
{
  paused = pauseSimulation;
}
 
SDateTime SEnvironment::GetDateTime()
{
  SDateTime tempDateTime;
  double second = 0.0;
 
  if(universalClock)
    universalClock->GetGregorianDateTime(tempDateTime.year, tempDateTime.month, tempDateTime.day, tempDateTime.hour, tempDateTime.minute, second);
 
  tempDateTime.second = static_cast<int> (second);
  return tempDateTime;
}
 
void SEnvironment::SetDateTime(const SDateTime& dateTime)
{
  double second = static_cast<double> (dateTime.second);
  if(universalClock)
    universalClock->SetGregorianDateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute, second);
}
 
Ogre::Degree SEnvironment::GetLongitude()
{
  return observerLongitude;
}
 
void SEnvironment::SetLongitude(const Ogre::Degree& newLongitude)
{
  observerLongitude = newLongitude;
}
 
Ogre::Degree SEnvironment::GetLatitude()
{
  return observerLatitude;
}
 
void SEnvironment::SetLatitude(const Ogre::Degree& newLatitude)
{
  observerLatitude = newLatitude;
}
 
bool SEnvironment::frameStarted(const Ogre::FrameEvent& evt)
{
  if(!paused)
  {
    Ogre::Real updateTime = 0.0f;
    if(universalClock)
      if(universalClock->GetTimeScale() != 0.0f)
        universalClock->Update(evt.timeSinceLastFrame);
  }
 
  // Update sun
  if(sun)
    sun->Update();
 
  // Update moon
  if(moon)
    moon->Update();
 
  // Update water
  if(water)
    water->Update(evt.timeSinceLastFrame);
 
  // Update sky
  if(sky)
    sky->Update(evt.timeSinceLastFrame);
 
  return true;
}
 
void SEnvironment::_NotifyEnvironmentComponentRegisterRenderTarget(Ogre::Viewport* targetViewport)
{
  // Check if the viewport's parent render target is allready registered.
  Ogre::RenderTarget* parentRenderTarger = targetViewport->getTarget();
  RenderTargetList::iterator searchedRenderTarget = mRenderTargetList.find(parentRenderTarger);
  if(searchedRenderTarget != mRenderTargetList.end())
  {
    // Found, drop from the list and then push back.
    parentRenderTarger->removeListener(this);
    parentRenderTarger->addListener(this);
  }
}
 
void SEnvironment::_NotifyEnvironmentComponentUnRegisterRenderTarget(Ogre::Viewport* targetViewport)
{
  // Check if the viewport's parent render target is allready registered.
  Ogre::RenderTarget* parentRenderTarger = targetViewport->getTarget();
  RenderTargetList::iterator searchedRenderTarget = mRenderTargetList.find(parentRenderTarger);
  if(searchedRenderTarget != mRenderTargetList.end())
  {
    // Found, drop from the list
    parentRenderTarger->removeListener(this);
  }
}
 
void SEnvironment::UpdateCamera(SViewPort* viewport)
{
  if(water && water->GetEnable())
  {
    bool hasStereo = viewport->IsStereoViewportRegistered();
    if (hasStereo)
      viewport->UnregisterStereoViewport();
 
    water->UpdateCamera(viewport);
 
    if (hasStereo)
      viewport->RegisterStereoViewport();
  }
 
  if(sky)
    sky->UpdateCamera(viewport);
}
}