SO3DeferredLightSpot.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/SO3DeferredLightSpot.h"
 
namespace SO3
{
 
SDeferredLightSpot::SDeferredLightSpot(Ogre::Light* originalLight, SDeferredLightMaterialGenerator* typeLightMaterialGenerator) : SDeferredLightImpl(originalLight, "Spot", typeLightMaterialGenerator)
{
}
 
SDeferredLightSpot::~SDeferredLightSpot()
{
}
 
void SDeferredLightSpot::SetAttenuation()
{
}
 
void SDeferredLightSpot::RebuildGeometry()
{
  // Do not take care about new radius
  Ogre::Real height = ogreParentLight->getAttenuationRange();
  Ogre::Radian coneRadiusAngle = std::min<Ogre::Radian>(ogreParentLight->getSpotlightOuterAngle(), Ogre::Degree(179.0f)) / 2; // Avoid Pi/2 max angle
  Ogre::Real newRadius = Ogre::Math::Tan(coneRadiusAngle) * height;
 
  delete mRenderOp.vertexData;
  delete mRenderOp.indexData;
  mRenderOp.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
  mRenderOp.indexData = new Ogre::IndexData();
  mRenderOp.vertexData = new Ogre::VertexData();
  mRenderOp.useIndexes = true;
 
  // Generate the geometry
  SBaseMeshsTools::CreateCone(mRenderOp.vertexData, mRenderOp.indexData, newRadius, height, 20);
 
  // Set bounding box
  setBoundingBox(Ogre::AxisAlignedBox(Ogre::Vector3(-newRadius, 0, -newRadius), Ogre::Vector3(newRadius, height, newRadius)));
  //mRadius = newRadius;
}
 
Ogre::Real SDeferredLightSpot::getBoundingRadius() const
{
  // TODO
  return 0.0f;
}
 
Ogre::Real SDeferredLightSpot::getSquaredViewDepth(const Ogre::Camera* cam) const
{
  Ogre::Vector3 dist = cam->getDerivedPosition() - getParentSceneNode()->_getDerivedPosition();
  return dist.squaredLength();
}
 
void SDeferredLightSpot::getWorldTransforms(Ogre::Matrix4* xform) const
{
  Ogre::Quaternion quat = Ogre::Vector3::UNIT_Y.getRotationTo(ogreParentLight->getDerivedDirection());
  xform->makeTransform(ogreParentLight->getDerivedPosition(), Ogre::Vector3::UNIT_SCALE, quat);
}
 
void SDeferredLightSpot::CheckCullingMode(Ogre::Camera* camera, Ogre::Pass* pass)
{
  // Check if the camera is inside the sphere geometry (small epsilon fix to account for the fact that we aren't a true sphere).
  Ogre::Vector3 lightPos = ogreParentLight->getDerivedPosition();
  Ogre::Vector3 lightDir = ogreParentLight->getDerivedDirection();
  Ogre::Radian attAngle = std::min<Ogre::Radian>(ogreParentLight->getSpotlightOuterAngle(), Ogre::Degree(179.0f));
        
  //Some trigonometry needed here.  
  Ogre::Vector3 lightToCamDir = camera->getDerivedPosition() - lightPos;
  //Extend the analytic cone's radius by the near clip range by moving its tip accordingly.
  Ogre::Vector3 clipRangeFix = -lightToCamDir * Ogre::Math::Tan(attAngle/2);
  Ogre::Real distanceFromLight = lightToCamDir.normalise() + camera->getNearClipDistance();
 
  Ogre::Real cosAngle = lightToCamDir.dotProduct(lightDir);
  Ogre::Radian angle = Ogre::Math::ACos(cosAngle);
 
  //Check whether we will see the cone from our current POV.
  if ((distanceFromLight < (ogreParentLight->getAttenuationRange() + clipRangeFix.length())) && (angle <= attAngle))
  {
    pass->setCullingMode(Ogre::CULL_ANTICLOCKWISE);
    //pass->setDepthFunction(Ogre::CMPF_GREATER_EQUAL);
  }
  else
  {
    pass->setCullingMode(Ogre::CULL_CLOCKWISE);
    //pass->setDepthFunction(Ogre::CMPF_LESS_EQUAL);
  }
  pass->setDepthCheckEnabled(true);
  pass->setDepthFunction(Ogre::CMPF_ALWAYS_PASS);
}
 
}