SO3LightShaft.cpp

Go to the documentation of this file.

 
#include "SO3Renderer/SO3LightShaft.h"
#include "SO3SceneGraph/SO3Light.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Utils/SO3ConversionTools.h"
#include "SO3Renderer/SO3Root.h"
 
namespace SO3
{
 
  SLightShaft::SLightShaft()
  {
  }
 
  SLightShaft::SLightShaft(SNode* parent, float minStep, float nearClip, float farClip, Ogre::Radian fov)
  {
    mParent = parent;
    mBillboardSet = 0;
    mSceneMgr = parent->GetParentScene()->GetOgreScenePointer();
    currentScene = parent->GetParentScene();
    mLightCamera = 0;
    mMinStep = minStep;
    mNeedUpdate = true;
 
    mShaftMaterial.reset();
    mDepthMaterial.reset();
    mDepthTexture.reset();
 
    // create a material copy
    // set default parameters
 
    mLightCamera = mSceneMgr->createCamera(mParent->GetName() + "_LightCamera");
    mLightCamera->setProjectionType(Ogre::PT_PERSPECTIVE);
 
    // Not forget to set near+far distance in materials
    mParent->GetOgreSceneNodePointer()->attachObject(mLightCamera);
 
    mBillboardSet = mSceneMgr->createBillboardSet(mParent->GetName() + "_LightBillboardSet", 60);
    mBillboardSet->setBillboardRotationType(Ogre::BBR_VERTEX);
    mBillboardSet->setBillboardType(Ogre::BBT_POINT);
    mBillboardSet->setCastShadows(false);
    mBillboardSet->setSortingEnabled(false);
    mBillboardSet->setDefaultWidth(1.0f);
    mBillboardSet->setDefaultHeight(1.0f);
 
    mParent->GetOgreSceneNodePointer()->attachObject(mBillboardSet);
 
    bool isrect = false;
    if (mParent->GetNodeType() == SNode::LIGHT_TYPE_ID)
      isrect = static_cast<SLight*>(mParent)->GetType() == SLight::SO3_RECT_LIGHT;
 
    // Create our billboardset for volumetric rendering
    try
    {
      Ogre::MaterialPtr smat = static_cast<Ogre::MaterialPtr>(isrect ? Ogre::MaterialManager::getSingleton().getByName("SO3/LightShaftsRect") : Ogre::MaterialManager::getSingleton().getByName("SO3/LightShafts"));
      if (smat)
      {
        mShaftMaterial = smat->clone(mParent->GetName() + "/SO3/LightShafts", "SO3/Internal");
        mShaftMaterial->getTechnique(0)->setSchemeName("SO3/LIGHTSHAFT");
        mShaftMaterial->setReceiveShadows(false);
        mShaftMaterial->load();
        mBillboardSet->setMaterialName(mShaftMaterial->getName());
      }
 
      Ogre::MaterialPtr dmat = static_cast<Ogre::MaterialPtr>(Ogre::MaterialManager::getSingleton().getByName("SO3/LightShaftsDepth"));
      if (dmat)
      {
        mDepthMaterial = dmat->clone(mParent->GetName() + "/SO3/LightShaftsDepth", "SO3/Internal");
        mDepthMaterial->setReceiveShadows(false);
        mDepthMaterial->load();
      }
    }
    catch (Ogre::Exception &)
    {
      // material error
      mShaftMaterial.reset();
      mDepthMaterial.reset();
    }
 
    // Create a rush of billboards according to the frustum of the camera(mLightCamera)
    SetLightClipping(nearClip, farClip);
    CreateLightCameraRTT();
    Ogre::MaterialManager::getSingleton().addListener(this, "SO3/" + mParent->GetName() + "/LightShafts");
  }
 
  SLightShaft::~SLightShaft()
  {
    Ogre::MaterialManager::getSingleton().removeListener(this, "SO3/" + mParent->GetName() + "/LightShafts");
 
    mBillboardSet->clear();
    mSceneMgr->destroyBillboardSet(mBillboardSet->getName());
 
 
    if (mShaftMaterial)
    {
      mShaftMaterial->unload();
      Ogre::MaterialManager::getSingletonPtr()->remove(mShaftMaterial->getHandle());
    }
 
    if (mDepthMaterial)
    {
      mDepthMaterial->unload();
      Ogre::MaterialManager::getSingletonPtr()->remove(mDepthMaterial->getHandle());
    }
 
    mShaftMaterial.reset();
    mDepthMaterial.reset();
 
    if (mDepthTexture)
    {
      Ogre::RenderTarget* RT_Texture = mDepthTexture->getBuffer()->getRenderTarget();
      RT_Texture->removeAllViewports();
      Ogre::Root::getSingleton().detachRenderTarget(RT_Texture);
      Ogre::TextureManager::getSingleton().remove(mDepthTexture->getHandle());
    }
 
    mDepthTexture.reset();
    mSceneMgr->destroyCamera(mLightCamera);
  }
 
  Ogre::Technique* SLightShaft::handleSchemeNotFound(unsigned short schemeIndex, const Ogre::String& schemeName, Ogre::Material* originalMaterial, unsigned short lodIndex, const Ogre::Renderable* rend)
  {
    return mDepthMaterial->getTechniques()[0];
  }
 
  void SLightShaft::preRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
    Update();
    mMaterials.empty();
    UpdatePosition();
    mBillboardSet->setVisible(false);
  }
 
  void SLightShaft::postRenderTargetUpdate(const Ogre::RenderTargetEvent& evt)
  {
    mBillboardSet->setVisible(true);
  }
 
  void SLightShaft::UpdatePosition()
  {
    // Upload current position to light shafts materials
    if (mShaftMaterial)
      mShaftMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("uLightPosition", mParent->GetGlobalPosition());
 
    if (mDepthMaterial)
      mDepthMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("uLightPosition", mParent->GetGlobalPosition());
 
    // We've to update the texture projection matrix
    UpdateTextureProjectionMatrix();
  }
 
  void SLightShaft::UpdateTextureProjectionMatrix()
  {
    const Ogre::Matrix4 PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE(
      0.5, 0, 0, 0.5,
      0, -0.5, 0, 0.5,
      0, 0, 1, 0,
      0, 0, 0, 1);
 
    Ogre::Matrix4 TexViewProj = PROJECTIONCLIPSPACE2DTOIMAGESPACE_PERSPECTIVE * mLightCamera->getProjectionMatrixWithRSDepth() * mLightCamera->getViewMatrix();
    if (mShaftMaterial)
      mShaftMaterial->getTechnique(0)->getPass(0)->getVertexProgramParameters()->setNamedConstant("uTexViewProj", TexViewProj);
  }
 
  void SLightShaft::CreateLightShafts()
  {
    if (mShaftMaterial)
    {
      // Get frustum corners to calculate near/far planes dimensions
      const Ogre::Vector3 *FrustumCorners = mLightCamera->getWorldSpaceCorners();
 
      // Calcule near and far planes dimensions
      float NearWidth = (FrustumCorners[0] - FrustumCorners[1]).length(),
        NearHeigth = (FrustumCorners[1] - FrustumCorners[2]).length(),
        FarWidth = (FrustumCorners[4] - FrustumCorners[5]).length(),
        FarHeigth = (FrustumCorners[5] - FrustumCorners[6]).length();
 
      //clear the billboard set
      mBillboardSet->clear();
 
      // Add billboards
      Ogre::Billboard *CurrentBB = 0;
 
      float diff = FarWidth - NearWidth;
      float dist = 0.0f;
      float clip = mLightCamera->getFarClipDistance() - mLightCamera->getNearClipDistance();
 
#ifdef _WIN32
      int maxCount = 60;
#else
      int maxCount = 40;
#endif
 
      bool isrect = false;
      Ogre::Vector2f rect;
      if (mParent->GetNodeType() == SNode::LIGHT_TYPE_ID)
      {
        SLight* light = static_cast<SLight*>(mParent);
        isrect = light->GetType() == SLight::SO3_RECT_LIGHT;
        rect = light->GetSourceSize();
      }
 
      for (int k = 0; dist < mLightCamera->getFarClipDistance() && (k < maxCount); k++)
      {
        dist = mMinStep * k * k * diff * 0.5f;
        float width = isrect ? rect.x + (dist / clip * diff) : dist / clip * diff;
        float height = isrect ? rect.y + (dist / clip * diff) : dist / clip * diff;
 
        CurrentBB = mBillboardSet->createBillboard(Ogre::Vector3(0, 0, -dist));
        CurrentBB->setDimensions(width, height);
      }
    }
  }
 
  void SLightShaft::Update()
  {
    if (mNeedUpdate)
    {
      CreateLightShafts();
      mNeedUpdate = false;
    }
  }
 
  void SLightShaft::CreateLightCameraRTT()
  {
    if (mShaftMaterial)
    {
      Ogre::PixelFormat rttformat;
      bool pfsupport = SRoot::getSingleton().GetRttPixelFormat(rttformat, false, true);
      if (!pfsupport)
        pfsupport = SRoot::getSingleton().GetRttPixelFormat(rttformat, true, true);
 
      if (!pfsupport)
        rttformat = Ogre::PF_R8G8B8;
 
      // Creat a texture for use as rtt
      mDepthTexture = Ogre::TextureManager::getSingleton().createManual(mParent->GetName() + "_LightDepthMap", "SO3/Internal", Ogre::TEX_TYPE_2D, 128, 128, 0, rttformat, Ogre::TU_RENDERTARGET);
      Ogre::RenderTarget* RT_Texture = mDepthTexture->getBuffer()->getRenderTarget();
      Ogre::Viewport* RT_Texture_Viewport = RT_Texture->addViewport(mLightCamera);
      RT_Texture_Viewport->setClearEveryFrame(true);
      RT_Texture_Viewport->setBackgroundColour(Ogre::ColourValue::White);
      RT_Texture_Viewport->setOverlaysEnabled(false);
      RT_Texture_Viewport->setSkiesEnabled(false);
      RT_Texture_Viewport->setShadowsEnabled(false);
      RT_Texture_Viewport->setMaterialScheme("SO3/" + mParent->GetName() + "/LightShafts");
 
      // Add our depth listener
      RT_Texture->addListener(this);
 
      // Fill the texture in our material
      mShaftMaterial->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTexture(mDepthTexture);
    }
  }
 
  void SLightShaft::SetMinStep(const float minStep)
  {
    mMinStep = minStep;
    mNeedUpdate = true;
  }
 
  void SLightShaft::SetCookieTexture(std::string path)
  {
  }
 
  void SLightShaft::SetLightClipping(float nearClip, float farClip)
  {
    if (nearClip < 0.1)
      nearClip = 0.1;
 
    if (farClip < 0.2)
      farClip = 0.2;
 
    if (farClip > 1000.0)
      farClip = 1000.0;
 
    if (nearClip >= farClip)
      nearClip = farClip / 8.0f;
 
    mLightCamera->setProjectionType(Ogre::PT_PERSPECTIVE);
    mLightCamera->setNearClipDistance(nearClip);
    mLightCamera->setFarClipDistance(farClip);
    mLightCamera->setAspectRatio(1.0f);
    mLightCamera->setDebugDisplayEnabled(false);
    mLightCamera->setVisible(true);
 
    if (mShaftMaterial)
      mShaftMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("uLightFarClipDistance", farClip + nearClip);
 
    if (mDepthMaterial)
      mDepthMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("uLightFarClipDistance", farClip + nearClip);
    
    mNeedUpdate = true;
  }
 
  void SLightShaft::SetAttenuation(Ogre::Vector4 attenuation)
  {
    if (mShaftMaterial)
      mShaftMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("uAttenuation", attenuation);
  }
 
  void SLightShaft::SetLightFov(Ogre::Radian fov)
  {
    mLightCamera->setFOVy(fov);
    mNeedUpdate = true;
  }
 
  void SLightShaft::SetColor(Ogre::ColourValue col)
  {
    if (mShaftMaterial)
      mShaftMaterial->getTechnique(0)->getPass(0)->getFragmentProgramParameters()->setNamedConstant("uLightColor", col);
  }
 
}