SO3DeferredLightPoint.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/SO3DeferredLightPoint.h"
 
namespace SO3
{
 
SDeferredLightPoint::SDeferredLightPoint(Ogre::Light* originalLight, SDeferredLightMaterialGenerator* typeLightMaterialGenerator) : SDeferredLightImpl(originalLight, "Point", typeLightMaterialGenerator)
{
  radius = 0.0f;
}
 
SDeferredLightPoint::~SDeferredLightPoint()
{
}
 
void SDeferredLightPoint::SetAttenuation()
{
  // Original model
  /*float outerRadius = ogreParentLight->getAttenuationRange();
  float c = ogreParentLight->getAttenuationConstant();
  float b = ogreParentLight->getAttenuationLinear();
  float a = ogreParentLight->getAttenuationQuadric();
 
  // Avoid a bad zero division
  if (c != 1.0f || b != 0.0f || a != 0.0f)
  {
    // Calculate radius from Attenuation (dmax at wich attenuation factor is close to 0)
    int threshold_level = 10;// difference of 10-15 levels deemed unnoticeable
    float threshold = 1.0f/((float)threshold_level/256.0f); 
 
    // Use quadratic formula to determine outer radius
    c = c-threshold;
    float d=sqrt(b*b-4*a*c);
    outerRadius = (-2*c)/(b+d);
    outerRadius *= 1.2;
  }
  radius = outerRadius;*/
 
  // Corrected Model
  /*
  // Calculate radius from Attenuation (dmax at wich attenuation factor is close to 0)
  int threshold_level = 5;// difference of 10-15 levels deemed unnoticeable
  float threshold = 1.0f/((float)threshold_level/256.0f); 
 
  float outerRadius = ogreParentLight->getAttenuationRange();
  float c = ogreParentLight->getAttenuationConstant();
  float b = ogreParentLight->getAttenuationLinear();
  // minimum value for quadratic for make the formule works 0.01
  float a = std::max<float>(ogreParentLight->getAttenuationQuadric(), 0.01);
 
  // Use quadratic formula to determine outer radius
  c = c-threshold;
  float d=sqrt(b*b-4*a*c);
  outerRadius = (-b + d) / (2*a);
  radius = outerRadius * 1.2f;
  */
  
  radius = ogreParentLight->getAttenuationRange() * 1.5f;
}
 
void SDeferredLightPoint::RebuildGeometry()
{
  //Ogre::Real newRadius = ogreParentLight->getAttenuationRange();
  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
  //radius = ogreParentLight->getAttenuationRange() * 1.2;
  SBaseMeshsTools::CreateSphere(mRenderOp.vertexData, mRenderOp.indexData, radius, 10, 10, false, false);
 
  // Set bounding box
  setBoundingBox(Ogre::AxisAlignedBox(Ogre::Vector3(-radius, -radius, -radius), Ogre::Vector3(radius, radius, radius)));
  // and sphere radius
  //radius = newRadius;
}
 
Ogre::Real SDeferredLightPoint::getBoundingRadius() const
{
  return radius;
}
 
Ogre::Real SDeferredLightPoint::getSquaredViewDepth(const Ogre::Camera* cam) const
{
  Ogre::Vector3 dist = cam->getDerivedPosition() - getParentSceneNode()->_getDerivedPosition();
  return dist.squaredLength();
}
 
void SDeferredLightPoint::getWorldTransforms(Ogre::Matrix4* xform) const
{
  xform->makeTransform(ogreParentLight->getDerivedPosition(), Ogre::Vector3::UNIT_SCALE, Ogre::Quaternion::IDENTITY);
}
 
void SDeferredLightPoint::CheckCullingMode(Ogre::Camera* camera, Ogre::Pass* pass)
{
  pass->setDepthCheckEnabled(true);
 
  // 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::Real distanceFromLight = camera->getDerivedPosition().distance(ogreParentLight->getDerivedPosition());
  if ((distanceFromLight) <= (radius + camera->getNearClipDistance() + 0.01))
  {
    pass->setCullingMode(Ogre::CULL_ANTICLOCKWISE);
  }
  else
  {
    pass->setCullingMode(Ogre::CULL_CLOCKWISE);
  }
  pass->setDepthFunction(Ogre::CMPF_ALWAYS_PASS);
}
 
}