SO3Engine/SO3SceneGraph/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "SO3Scene.h"
#include "SO3Environment.h"
#include "SO3Sun.h"
#include "SO3Moon.h"
#include "../SO3SceneGraph/SO3Camera.h"
#include "../SO3Renderer/SO3Viewport.h"
#include "../SO3Utils/SO3UniversalClock.h"
#include "../SO3Utils/SO3DateTime.h"

namespace SO3
{

SEnvironment::SEnvironment(SScene* parent, std::string environmentName) : SData(environmentName)
{
  scene = parent;
  viewport = 0;
  camera = 0;
  water = 0;
  sky = 0;
  paused = false;
  viewportListenerAdded = false;

  // Init position
  observerLatitude  = 45.0f;
  observerLongitude = 0.0f;

  // Init wind & humidity
  windSpeed = 1.0f;
  windDirection = Ogre::Vector2::UNIT_X;
  humidityFactor = 0.25f;

  // Time/date calculation
  universalClock = new SUniversalClock();
  // 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");

  // Add frame listener
  Ogre::Root::getSingleton().addFrameListener(this);

  // TEST
  //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);

  SetViewport(0);
  SAFE_DELETE(water);
  SAFE_DELETE(sky);
  SAFE_DELETE(moon);
  SAFE_DELETE(sun);
  SAFE_DELETE(universalClock);
}

SScene* SEnvironment::GetScene()
{
  return scene;
}

SViewPort* SEnvironment::GetViewport()
{
  return viewport;
}

void SEnvironment::SetViewport(SViewPort* targetViewport)
{
  if(viewportListenerAdded)
  {
    viewport->GetOgreViewPortPointer()->getTarget()->removeListener(this);
    viewportListenerAdded = false;
  }

  viewport = targetViewport;
  //NotifyCameraChanged(viewport->GetCamera());

  if(viewport == 0)
  {
    SetWaterEnable(false);
    SetSkyEnable(false);
    camera = 0;
  }
  else
  {
    // TODO
    camera = targetViewport->GetCamera();
  }
}

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::GetWaterEnable()
{
  return (water!=0);
}

void SEnvironment::SetWaterEnable(bool enableWater)
{
  if(enableWater)
  {  
    if(water == 0)
    {
      if(viewport)
      {
        if(camera != 0)
        {
          water = new SWater(this, "SO3/Internal/Environment/"+ name +"/Water", viewport, camera/*, 5000, 5000*/);

          // It's a little bit strange to set it here, but we need to register our rendertargetlistener AFTER hydrax one (or there will be issues when viewportRemoved will be called).
          viewport->GetOgreViewPortPointer()->getTarget()->addListener(this);
          viewportListenerAdded = true;
        }
      }
    }
  }
  else
  {
    if(water != 0)
      SAFE_DELETE(water);
  }
}

bool SEnvironment::GetSkyEnable()
{
  return (sky!=0);
}

void SEnvironment::SetSkyEnable(bool enableSky)
{
  if(enableSky)
  {
    if(sky == 0)
    {
      if(viewport != 0)
      {
          sky = new SSky(this, "SO3/Internal/Environment/"+ name +"Sky");
          sky->RegisterViewport(viewport);
      }
    }
  }
  else
  {
    if(sky != 0)
      SAFE_DELETE(sky);
  }
}

float SEnvironment::GetWindSpeed()
{
  return windSpeed;
}

void SEnvironment::SetWindSpeed(float newWindSpeed)
{
  windSpeed = newWindSpeed;
}

Ogre::Vector2 SEnvironment::GetWindDirection()
{
  return windDirection;
}

void SEnvironment::SetWindDirection(Ogre::Vector2 newWindDirection)
{
  windDirection = newWindDirection;
}

float SEnvironment::GetHumidity()
{
  return humidityFactor;
}

void SEnvironment::SetHumidity(float newHumidity)
{
  humidityFactor = newHumidity;
}

float SEnvironment::GetTimeSpeedFactor()
{
  return universalClock->GetTimeScale();
}

void SEnvironment::SetTimeSpeedFactor(float newTimeSpeedFactor)
{
  universalClock->SetTimeScale(newTimeSpeedFactor);
}

bool SEnvironment::GetPaused()
{
  return paused;
}

void SEnvironment::SetPaused(bool pauseSimulation)
{
  paused = pauseSimulation;
}

SDateTime SEnvironment::GetDateTime()
{
  SDateTime tempDateTime;
  double second;

  universalClock->GetGregorianDateTime(tempDateTime.year, tempDateTime.month, tempDateTime.day, tempDateTime.hour, tempDateTime.minute, second);
  tempDateTime.second = static_cast<int> (second);
  return tempDateTime;
}

void SEnvironment::SetDateTime(SDateTime dateTime)
{
  double second = static_cast<double> (dateTime.second);
  universalClock->SetGregorianDateTime(dateTime.year, dateTime.month, dateTime.day, dateTime.hour, dateTime.minute, second);
}

Ogre::Degree SEnvironment::GetLongitude()
{
    return observerLongitude;
}

void SEnvironment::SetLongitude(Ogre::Degree newLongitude)
{
  observerLongitude = newLongitude;
}

Ogre::Degree SEnvironment::GetLatitude()
{
  return observerLatitude;
}

void SEnvironment::SetLatitude(Ogre::Degree newLatitude)
{
  observerLatitude = newLatitude;
}

bool SEnvironment::frameStarted(const Ogre::FrameEvent& evt)
{
  if(!paused)
  {
    Ogre::Real updateTime = 0.0f;
    if(universalClock->GetTimeScale() != 0.0f)
      universalClock->Update(evt.timeSinceLastFrame);

    // Update sun
    sun->Update();

    // Update moon
    moon->Update();

    // Update water
    if(water != 0)
      water->Update(evt.timeSinceLastFrame);

    // Update sky
    if(sky != 0)
      sky->Update(evt.timeSinceLastFrame);
  }
  return true;
}

void SEnvironment::viewportRemoved(const Ogre::RenderTargetViewportEvent& evt)
{
  if(viewport != 0)
  {
    if(evt.source == viewport->GetOgreViewPortPointer())
    {
      // Reset viewport, will delete water and sky if they are activated.
      SetViewport(0);
    }
  }
}

void NotifyCameraChanged(SCamera* targetCamera)
{
  // TODO
}

}

---