SO3DeferredLightCompositionPass.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/SO3DeferredLightCompositionPass.h"
#include "SO3SceneGraph/SO3Light.h"
#include "SO3Renderer/SO3Root.h"
#include "SO3SceneGraph/SO3Scene.h"
#include "SO3Renderer/DeferredShading/SO3DeferredShadowManager.h"
#include "Ogre.h"
 
namespace SO3
{
 
SDeferredLightRenderOperation::SDeferredLightRenderOperation(Ogre::CompositorInstance* instance, const Ogre::CompositionPass* pass)
{
  mViewport = instance->getChain()->getViewport();
 
  // Reference to deferred light manager
  deferredLightManager = SDeferredLightManager::getSingletonPtr();
 
  //Get the names of the GBuffer textures
  const Ogre::CompositionPass::InputTex& input0 = pass->getInput(0);
  mTexName0 = instance->getTextureInstanceName(input0.name, input0.mrtIndex);
  const Ogre::CompositionPass::InputTex& input1 = pass->getInput(1);
  mTexName1 = instance->getTextureInstanceName(input1.name, input1.mrtIndex);
 
  // Create the ambient light
  ambientLight = new SDeferredLightAmbient(SDeferredLightManager::getSingleton().GetDeferredLightAmbientMaterialGenerator());
  if(ambientLight)
  {
    const Ogre::MaterialPtr& mat = ambientLight->getMaterial();
    mat->load();
  }
}
 
SDeferredLightRenderOperation::~SDeferredLightRenderOperation()
{
  SO3_SAFE_DELETE(ambientLight);
}
 
void injectTechnique(Ogre::SceneManager* sm, Ogre::Technique* tech, Ogre::Renderable* rend, const Ogre::LightList* lightList)
{
  for(unsigned short i=0; i<tech->getNumPasses(); ++i)
  {
    Ogre::Pass* pass = tech->getPass(i);
    sm->_injectRenderWithPass(pass, rend, false, false, lightList);
  }
}
 
void SDeferredLightRenderOperation::execute(Ogre::SceneManager* sm, Ogre::RenderSystem* rs)
{
  // Get the active camera
  Ogre::Camera* cam = mViewport->getCamera();
 
  // Updating ambiant light
  if(ambientLight)
  {
    ambientLight->UpdateFromCamera(cam);
    Ogre::Technique* tech = ambientLight->getMaterial()->getBestTechnique();
    injectTechnique(sm, tech, ambientLight, 0);
  }
 
  // Updating all lights that affects the frustrum
  const Ogre::LightList& lightList = sm->_getLightsAffectingFrustum();
  for (Ogre::LightList::const_iterator it = lightList.begin(); it != lightList.end(); it++)
  {
    // Used by Ogre::SceneManager::_injectRenderWithPass
    Ogre::LightList ll;
    ll.push_back(*it);
 
    // Do we need to create a new SDeferredLight for the OgreLight?
    SDeferredLight* deferredLight = deferredLightManager->CreateOrRetrieve(*it);
 
    // Update the light.
    deferredLight->UpdateFromParent();
    deferredLight->UpdateFromCamera(cam);
    Ogre::SimpleRenderable* renderedGeometry = deferredLight->GetRenderable();
    Ogre::Technique* tech = renderedGeometry->getMaterial()->getBestTechnique();
 
                //Update shadow texture
    if (deferredLight->GetCastShadows() && (tech->getNumPasses() > 0))
                {
                        Ogre::Pass* pass = tech->getPass(0);
                        #if SO3_ENABLE_DEFERRED_CUSTOM_SHADOWS == 0
                                Ogre::SceneManager::RenderContext* context = sm->_pauseRendering();
                                sm->prepareShadowTextures(cam, mViewport, &ll);
                                sm->_resumeRendering(context);
                                const Ogre::TexturePtr& shadowTexture = sm->getShadowTexture(0);
                        #else
                                const Ogre::TexturePtr& shadowTexture = SDeferredShadowManager::getSingleton().PrepareShadowTexture(cam, mViewport, (*it), pass);
                        #endif
 
                        // Check that the tu is correctly binded
                        Ogre::TextureUnitState* tus = pass->getTextureUnitState("ShadowMap");
                        if(tus->_getTexturePtr() != shadowTexture)
                                tus->_setTexturePtr(shadowTexture);
                }
                injectTechnique(sm, tech, renderedGeometry, &ll);
  }
}
 
Ogre::CompositorInstance::RenderSystemOperation* SDeferredLightCompositionPass::createOperation(Ogre::CompositorInstance* instance, const Ogre::CompositionPass* pass)
{
  return OGRE_NEW SDeferredLightRenderOperation(instance, pass);
}
 
}