SO3Light.cpp

Go to the documentation of this file.

 
#include "SO3SceneGraph/SO3Light.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
 
namespace SO3
{
 
  SLight::SLight(SScene* parent, const std::string& lightName) : SNode(parent, lightName, SNode::LIGHT_TYPE_ID)
  {
    mShadowFarDistance = 0;
    O3Light = currentScene->GetOgreScenePointer()->createLight(lightName);
    UpdateShadowFarDistance(currentScene->O3SceneManager->getShadowFarDistance());
    UpdateShadowFarClipDistance(currentScene->O3SceneManager->getShadowDirectionalLightExtrusionDistance());
 
    mLightShaft = 0;
    mVolumetric = false;
    mRange = 1000.0f;
 
    ogreMovableObject = O3Light;
    O3SceneNode->attachObject(O3Light);
    SetAttenuation(mRange);
  }
 
  SLight::SLight() : SNode(0, "", SNode::LIGHT_TYPE_ID)
  {
    // Forbiden (private);
  }
 
  SLight::~SLight()
  {
    SAFE_DELETE(mLightShaft);
    O3SceneNode->detachObject(O3Light);
    currentScene->GetOgreScenePointer()->destroyLight(O3Light);
    O3Light = 0;
    ogreMovableObject = 0;
  }
 
  Ogre::Light* SLight::GetOgreLightPointer()
  {
    return O3Light;
  }
 
  void SLight::UpdateVolumetric(bool force)
  {
    float nrange = mRange;
    Ogre::Radian fov = Ogre::Degree(120.0f);
    switch (GetType())
    {
    case SO3_POINT_LIGHT:
      fov = Ogre::Degree(160.0f);
      break;
 
    case SO3_DIRECTIONAL_LIGHT:
      fov = Ogre::Degree(120.0f);
      nrange = 100000.0f;
      break;
 
    case SO3_SPOT_LIGHT:
    case SO3_RECT_LIGHT:
      fov = O3Light->getSpotlightOuterAngle();
      nrange *= 10.0f;
      break;
    }
 
    if (force && mVolumetric && O3Light->isVisible())
    {
      SAFE_DELETE(mLightShaft);
      mLightShaft = new SLightShaft(this, 0.0001f, nrange * 0.01f, nrange, fov);
    }
    else
    {
      if (mVolumetric && O3Light->isVisible() && !mLightShaft)
        mLightShaft = new SLightShaft(this, 0.0001f, nrange * 0.01f, nrange, fov);
      else if ((!O3Light->isVisible() || !mVolumetric) && mLightShaft)
        SAFE_DELETE(mLightShaft);
    }
 
    if (mLightShaft)
    {
      mLightShaft->SetColor(O3Light->getDiffuseColour() * O3Light->getPowerScale());
      mLightShaft->SetLightFov(fov);
      mLightShaft->SetLightClipping(nrange * 0.01f, nrange);
      mLightShaft->SetAttenuation(Ogre::Vector4(mRange, 0.1, 4.5f / mRange, 7.5f / (mRange*mRange)));
    }
  }
 
  void SLight::SetVolumetric(bool state)
  {
    mVolumetric = state;
    UpdateVolumetric();
  }
 
  bool SLight::GetVolumetric()
  {
    return mVolumetric;
  }
 
  void SLight::SetDiffuseColour(Ogre::ColourValue color)
  {
    O3Light->setDiffuseColour(color);
    UpdateVolumetric();
  }
 
  void SLight::SetSpecularColour(Ogre::ColourValue color)
  {
    O3Light->setSpecularColour(color);
  }
 
  void SLight::SetDiffuseColour(const int& diffuseColor)
  {
    O3Light->setDiffuseColour(ConversionTools::ScolToOgreColorRGBA(diffuseColor));
    UpdateVolumetric();
  }
 
  int SLight::GetDiffuseColour()
  {
    return ConversionTools::OgreToScolColorRGBA(O3Light->getDiffuseColour());
  }
 
  void SLight::SetSpecularColour(const int& specularColor)
  {
    O3Light->setSpecularColour(ConversionTools::ScolToOgreColorRGBA(specularColor));
  }
 
  int SLight::GetSpecularColour()
  {
    return ConversionTools::OgreToScolColorRGBA(O3Light->getSpecularColour());
  }
 
  void SLight::SetPowerScale(const float& powerScale)
  {
    float power = std::max(0.01f, powerScale);
    O3Light->setPowerScale(power);
    UpdateVolumetric();
  }
 
  float SLight::GetPowerScale()
  {
    return static_cast <float> (O3Light->getPowerScale());
  }
 
  void SLight::SetVisible(const bool& isVisible)
  {
    O3Light->setVisible(isVisible);
 
    if (mVolumetric)
    {
      if (isVisible)
        UpdateVolumetric();
      else
        SAFE_DELETE(mLightShaft);
    }
 
    //hack to force shadow texture destruction
    SShadowManager::ShadowType type = currentScene->GetShadowType();
    currentScene->SetShadowType(SShadowManager::ShadowType::SO3_SHADOWS_NONE);
    currentScene->SetShadowType(type);
  }
 
  bool SLight::GetVisible()
  {
    return O3Light->isVisible();
  }
 
  void SLight::SetAttenuation(const float& range, const float& constant, const float& linear, const float& quadratic)
  {
    mRange = std::max(0.01f, range);
    if (O3Light->getType() == Ogre::Light::LT_DIRECTIONAL)
      O3Light->setAttenuation(100000.0f, constant, 0.0f, 0.0f);
    else
      O3Light->setAttenuation(range, constant, linear, quadratic);
  }
 
  void SLight::SetAttenuation(const float& range)
  {
    SetAttenuation(range, 1.0, 0.45f / range, 7.5f / (range*range));
    UpdateVolumetric();
  }
 
  Ogre::Vector4 SLight::GetAttenuation()
  {
    return Ogre::Vector4(O3Light->getAttenuationRange(),
      O3Light->getAttenuationConstant(),
      O3Light->getAttenuationLinear(),
      O3Light->getAttenuationQuadric());
  }
 
  void SLight::SetShadowFarDistance(const float& distance)
  {
    O3Light->setShadowFarDistance(distance);
    mShadowFarDistance = distance;
  }
 
  void SLight::UpdateShadowFarDistance(const float& distance)
  {
    if (mShadowFarDistance == 0)
      O3Light->setShadowFarDistance(distance);
  }
 
  void SLight::UpdateShadowFarClipDistance(const float& distance)
  {
    O3Light->setShadowNearClipDistance(0.1f);
    O3Light->setShadowFarClipDistance(distance);
  }
 
  float SLight::GetShadowFarDistance()
  {
    return O3Light->getShadowFarDistance();
  }
 
  void SLight::SetType(const LightType& type)
  {
    O3Light->setType(static_cast <Ogre::Light::LightTypes> (type));
    SetAttenuation(mRange);
    UpdateVolumetric(true);
  }
 
  SLight::LightType SLight::GetType()
  {
    return static_cast <SLight::LightType> (O3Light->getType());
  }
 
  void SLight::SetSpotlightInnerAngle(const float& radianAngle)
  {
    O3Light->setSpotlightInnerAngle(Ogre::Radian(radianAngle));
  }
 
  float SLight::GetSpotlightInnerAngle()
  {
    return static_cast <float> (O3Light->getSpotlightInnerAngle().valueRadians());
  }
 
  void SLight::SetSpotlightOuterAngle(const float& radianAngle)
  {
    O3Light->setSpotlightOuterAngle(Ogre::Radian(radianAngle));
    UpdateVolumetric();
  }
 
  float SLight::GetSpotlightOuterAngle()
  {
    return static_cast <float> (O3Light->getSpotlightOuterAngle().valueRadians());
  }
 
  void SLight::SetSpotlightFalloff(const float& value)
  {
    O3Light->setSpotlightFalloff(value);
  }
 
  float SLight::GetSpotlightFalloff()
  {
    return O3Light->getSpotlightFalloff();
  }
 
  void SLight::SetSourceSize(float x, float y)
  {
    O3Light->setSourceSize(x, y);
    UpdateVolumetric();
  }
 
  Ogre::Vector2f SLight::GetSourceSize()
  {
    return O3Light->getSourceSize();
  }
 
  void SLight::SetCastShadows(const bool& castShadows)
  {
    O3Light->setCastShadows(castShadows);
    //hack to force shadow texture destruction
    SShadowManager::ShadowType type = currentScene->GetShadowType();
    currentScene->SetShadowType(SShadowManager::ShadowType::SO3_SHADOWS_NONE);
    currentScene->SetShadowType(type);
  }
 
  bool SLight::GetCastShadows()
  {
    return O3Light->getCastShadows();
  }
 
  void SLight::SetRenderingDistance(const float& distance)
  {
    return O3Light->setRenderingDistance(distance);
  }
 
  float SLight::GetRenderingDistance()
  {
    return O3Light->getRenderingDistance();
  }
 
  Ogre::Vector3 SLight::GetBoundingBoxSize(const bool& childs)
  {
    if (childs)
      return GetSonsBoundingBox();
 
    return O3Light->getBoundingBox().getSize();
  }
 
  Ogre::Vector3 SLight::GetBoundingBoxCenter(const bool& childs)
  {
    return O3Light->getBoundingBox().getCenter();
  }
 
  Ogre::Vector3 SLight::GetWorldBoundingBoxSize(const bool& childs)
  {
    if (childs)
      return GetSonsWorldBoundingBox();
 
    return O3Light->getWorldBoundingBox(true).getSize();
  }
 
  Ogre::Vector3 SLight::GetWorldBoundingBoxCenter(const bool& childs)
  {
    return O3Light->getWorldBoundingBox(true).getCenter();
  }
}