SO3DeferredLight.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 "SO3Renderer/DeferredShading/SO3DeferredLight.h"
#include "SO3Renderer/DeferredShading/SO3DeferredLightImpl.h"
#include "SO3Renderer/DeferredShading/SO3DeferredLightPoint.h"
#include "SO3Renderer/DeferredShading/SO3DeferredLightDirectional.h"
#include "SO3Renderer/DeferredShading/SO3DeferredLightSpot.h"
#include "SO3Renderer/DeferredShading/SO3DeferredLightManager.h"
#include "SO3Utils/SO3BaseMeshsTools.h"
#include "OgreHardwareBufferManager.h"
#include "OgreCamera.h"
#include "OgreSceneNode.h"
#include "OgreTechnique.h"
#include "OgreSceneManager.h"
 
namespace SO3
{
 
SDeferredLight::SDeferredLight(Ogre::Light* originalLight) : ogreParentLight(originalLight)
{
  initialised = false;    // To force the first updateFromParent call
  currentType = ogreParentLight->getType();
  currentDeferredLight = 0;
  UpdateFromParent();
}
 
SDeferredLight::~SDeferredLight()
{
  SO3_SAFE_DELETE(currentDeferredLight);
}
 
void SDeferredLight::SetAttenuation()
{
  currentDeferredLight->SetAttenuation();
  currentDeferredLight->RebuildGeometry();
}
 
void SDeferredLight::UpdateFromParent()
{
  // Check if the light type as changed.
  Ogre::Light::LightTypes actualType = ogreParentLight->getType();
  if((currentType != actualType) || (!initialised))
  {
    SO3_SAFE_DELETE(currentDeferredLight);
    switch(actualType)
    {
    case Ogre::Light::LT_DIRECTIONAL:
      currentDeferredLight = new SDeferredLightDirectional(ogreParentLight, SDeferredLightManager::getSingleton().GetDeferredLightDirectionalMaterialGenerator());
      break;
    case Ogre::Light::LT_POINT:
      currentDeferredLight = new SDeferredLightPoint(ogreParentLight, SDeferredLightManager::getSingleton().GetDeferredLightPointMaterialGenerator());
      break;
    case Ogre::Light::LT_SPOTLIGHT:
      currentDeferredLight = new SDeferredLightSpot(ogreParentLight, SDeferredLightManager::getSingleton().GetDeferredLightSpotMaterialGenerator());
      break;
    }
    currentType = actualType;
    initialised = true;
  }
 
  //TODO : Don't do this unless something changed
  SetAttenuation();     
  //SetSpecularColour(ogreParentLight->getSpecularColour());
}
 
void SDeferredLight::UpdateFromCamera(Ogre::Camera* camera)
{
  //Set shader params
  const Ogre::MaterialPtr& mat = currentDeferredLight->getMaterial();
  if(!mat->isLoaded()) 
    mat->load();
 
  Ogre::Technique* tech = mat->getBestTechnique();
  Ogre::Vector3 farCorner = camera->getViewMatrix(true) * camera->getWorldSpaceCorners()[4];
 
  // get the vertex shader parameters
  Ogre::Pass* pass = tech->getPass(0);
  Ogre::GpuProgramParametersSharedPtr params = pass->getVertexProgramParameters();
 
  // set the camera's far-top-right corner
  if (params->_findNamedConstantDefinition("farCorner"))
    params->setNamedConstant("farCorner", farCorner);
 
  params = pass->getFragmentProgramParameters();
  if (params->_findNamedConstantDefinition("farCorner"))
    params->setNamedConstant("farCorner", farCorner);
 
  currentDeferredLight->CheckCullingMode(camera, pass);  
  if(GetCastShadows())
  {
    Ogre::Camera shadowCam("ShadowCameraSetupCam", 0);
    shadowCam._notifyViewport(camera->getViewport());
    Ogre::SceneManager* sm = ogreParentLight->_getManager();
 
    if (!ogreParentLight->getCustomShadowCameraSetup())
      sm->getShadowCameraSetup()->getShadowCamera(sm, camera, camera->getViewport(), ogreParentLight, &shadowCam, 0);
    else
      ogreParentLight->getCustomShadowCameraSetup()->getShadowCamera(sm, camera, camera->getViewport(), ogreParentLight, &shadowCam, 0);
 
    //Get the shadow camera position
    if (params->_findNamedConstantDefinition("shadowCamPos")) 
      params->setNamedConstant("shadowCamPos", shadowCam.getPosition());
 
    if (params->_findNamedConstantDefinition("shadowFarClip"))
      params->setNamedConstant("shadowFarClip", shadowCam.getFarClipDistance());
  }
}
 
bool SDeferredLight::GetCastShadows()
{
  return currentDeferredLight->GetCastShadows();
}
 
Ogre::SimpleRenderable* SDeferredLight::GetRenderable()
{
  assert(currentDeferredLight != 0);
  return currentDeferredLight;
}
 
bool SDeferredLight::GetDebugRendering()
{
  return currentDeferredLight->GetDebugRendering();
}
 
void SDeferredLight::SetDebugRendering(bool enableDebugRendering)
{
  currentDeferredLight->SetDebugRendering(enableDebugRendering);
}
 
 
}