SO3SkyLight.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/SO3SkyLight.h"
#include "SO3SceneGraph/SO3Environment.h"
#include "SO3SceneGraph/SO3Scene.h"
 
namespace SO3
{
 
SSkyLight::SSkyLight(SEnvironment* parent, const std::string& skyLightName, const Ogre::ColourValue& defaultBaseColour) : SData(skyLightName)
{
  parentEnvironment = parent;
  ogreSceneManager = parent->GetScene()->GetOgreScenePointer();
  lastJulDay = 0;
  ogreSkyLight = 0;
  ogreSkyLightSceneNode = 0;
  lastLatitude = Ogre::Degree(-91);   // Invalid value to force first update
  lastLongitude = Ogre::Degree(-181); // Invalid value to force first update
  forceUpdate = false;
 
  // Create a scene node
  ogreSkyLightSceneNode = ogreSceneManager->getRootSceneNode()->createChildSceneNode(skyLightName +"/Node");
 
  // Create a light.
  ogreSkyLight = ogreSceneManager->createLight(skyLightName +"/Light");
  ogreSkyLight->setType(Ogre::Light::LT_DIRECTIONAL);
  ogreSkyLight->setAttenuation(100000.0f, 1.0f, 0.0f, 0.0f);
 
  UpdateShadowFarDistance(ogreSceneManager->getShadowFarDistance());
  UpdateShadowFarClipDistance(ogreSceneManager->getShadowDirectionalLightExtrusionDistance());
 
  // Attach the light to the node
  ogreSkyLightSceneNode->attachObject(ogreSkyLight);
  ogreSkyLight->setVisible(false);
 
  // Configure light colour
  SetLightColour(defaultBaseColour);
}
 
SSkyLight::SSkyLight() : SData("")
{
  // Forbiden (private)
}
 
SSkyLight::~SSkyLight()
{
  if(ogreSkyLight)
  {
    if(ogreSkyLightSceneNode)
    {
      ogreSkyLightSceneNode->detachObject(ogreSkyLight);
      ogreSceneManager->getRootSceneNode()->removeAndDestroyChild(ogreSkyLightSceneNode->getName());
      ogreSkyLightSceneNode = 0;
    }
 
    ogreSceneManager->destroyLight(ogreSkyLight);
    ogreSkyLight = 0;
  }
 
  //restore default ambient light
  ogreSceneManager->setAmbientLight(parentEnvironment->GetScene()->GetAmbientLight());
 
  ogreSceneManager = 0;
  parentEnvironment = 0;
}
 
bool SSkyLight::GetEnable()
{
  if(ogreSkyLight)
   return ogreSkyLight->getVisible();
  else
    return false;
}
 
void SSkyLight::SetEnable(const bool& enable)
{
  if(ogreSkyLight)
    ogreSkyLight->setVisible(enable);
 
  //restore default ambient light
  if(!enable)
    ogreSceneManager->setAmbientLight(parentEnvironment->GetScene()->GetAmbientLight());
}
 
SEnvironment* SSkyLight::GetEnvironment()
{
  return parentEnvironment;
}
 
void SSkyLight::Update()
{
  double julDay = parentEnvironment->GetUniversalClock()->GetJulianDay();
  Ogre::Degree latitude = parentEnvironment->GetLatitude();
  Ogre::Degree longitude = parentEnvironment->GetLongitude();
 
  // Update only when necessary
  if((forceUpdate)||
     (lastJulDay == 0)||(lastJulDay != julDay)||
     (lastLatitude == Ogre::Degree(-91))||(lastLatitude != latitude)||
     (lastLongitude == Ogre::Degree(-181))||(lastLongitude != longitude))
  {
    // Update position
    Ogre::Vector3 tmpLightDirection = ComputeDirectionImpl(julDay);
    SetLightDirection(tmpLightDirection);
    lastJulDay = julDay;
    lastLatitude = latitude;
    lastLongitude = longitude;
    forceUpdate = false;
 
    // Update colour
    float gradientPoint = std::max(tmpLightDirection.y, 0.0f);
    if(ogreSkyLight)
    {
      ogreSkyLight->setDiffuseColour(lightColourGradient.GetColour(gradientPoint));
      ogreSkyLight->setSpecularColour(lightColourGradient.GetColour(gradientPoint));
 
      // update the scene ambient light color
      // hack to test for the sun
      if (ogreSkyLight->getCastShadows())
      {
        Ogre::ColourValue ccolor = parentEnvironment->GetScene()->GetAmbientLight();
        Ogre::ColourValue ncolor = lightColourGradient.GetColour(gradientPoint) * ccolor;
        if (((ncolor.r + ncolor.g + ncolor.b) / 3) >= ((ccolor.r + ccolor.g + ccolor.b) / 3))
          ogreSceneManager->setAmbientLight(ncolor);
      }
    }
 
    // Disable shadow when under horizon
    /*
    if(tmpLightDirection.y > -0.015f)
    {
      if(ogreSkyLight)
        ogreSkyLight->setCastShadows(true);
    }
    else
    {
      if(ogreSkyLight)
        ogreSkyLight->setCastShadows(false);
    }
    */
  }
}
 
const Ogre::Vector3 SSkyLight::GetLightDirection() const
{
  if(ogreSkyLight)
    return -(ogreSkyLight->getParentSceneNode()->_getDerivedOrientation() * Ogre::Vector3::NEGATIVE_UNIT_Z);
  else
    return Ogre::Vector3::ZERO;
}
 
void SSkyLight::SetLightDirection(const Ogre::Vector3& direction)
{
  if(ogreSkyLight)
    ogreSkyLight->getParentSceneNode()->setDirection(-direction);
}
 
const Ogre::ColourValue SSkyLight::GetLightColour(const float& level) const
{
  if(level == 1.0f)
    return baseColour;
  else
    return lightColourGradient.GetColour(level);
}
 
void SSkyLight::SetLightColour(const Ogre::ColourValue& newColour)
{
  baseColour = newColour;
  RefreshLightColourGradient();
  forceUpdate = true;
}
 
const Ogre::Vector3 SSkyLight::MakeDirection(const Ogre::Degree& azimuth, const Ogre::Degree& altitude)
{
    Ogre::Vector3 res;
    res.z = -Ogre::Math::Cos(azimuth) * Ogre::Math::Cos(altitude); // North 
    res.x = Ogre::Math::Sin(azimuth) * Ogre::Math::Cos(altitude);  // East
    res.y = Ogre::Math::Sin(altitude);                             // Zenith
    return res;
}
 
void SSkyLight::RefreshLightColourGradient()
{
  // 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.
  lightColourGradient.Clear();
  lightColourGradient.AddColourFrame(1.0,  baseColour);
  lightColourGradient.AddColourFrame(0.75, baseColour * 0.9f);
  lightColourGradient.AddColourFrame(0.55, baseColour * 0.85f);
  lightColourGradient.AddColourFrame(0.5,  baseColour * 0.75f);
  lightColourGradient.AddColourFrame(0.1,  baseColour * 0.3f);
  lightColourGradient.AddColourFrame(0.0,  Ogre::ColourValue::Black);
}
 
bool SSkyLight::GetCastShadowEnable()
{
  return ogreSkyLight->getCastShadows();
}
 
void SSkyLight::SetCastShadowEnable(const bool& enable)
{
  ogreSkyLight->setCastShadows(enable);
}
 
void SSkyLight::UpdateShadowFarDistance(const float& distance)
{
  ogreSkyLight->setShadowFarDistance(distance);
}
 
void SSkyLight::UpdateShadowFarClipDistance(const float& distance)
{
  ogreSkyLight->setShadowNearClipDistance(0.1f);
  ogreSkyLight->setShadowFarClipDistance(distance);
}
 
Ogre::Light* SSkyLight::GetOgreLight()
{
  return ogreSkyLight;
}
 
}