OgreMain/src/OgrePixelCountLodStrategy.cpp

   1 /*
   2 -----------------------------------------------------------------------------
   3 This source file is part of OGRE
   4     (Object-oriented Graphics Rendering Engine)
   5 For the latest info, see http://www.ogre3d.org/
   6
   7 Copyright (c) 2000-2006 Torus Knot Software Ltd
   8 Also see acknowledgements in Readme.html
   9
  10 This program is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU Lesser General Public License as published by the Free Software
  12 Foundation; either version 2 of the License, or (at your option) any later
  13 version.
  14
  15 This program is distributed in the hope that it will be useful, but WITHOUT
  16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  17 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
  18
  19 You should have received a copy of the GNU Lesser General Public License along with
  20 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  21 Place - Suite 330, Boston, MA 02111-1307, USA, or go to
  22 http://www.gnu.org/copyleft/lesser.txt.
  23
  24 You may alternatively use this source under the terms of a specific version of
  25 the OGRE Unrestricted License provided you have obtained such a license from
  26 Torus Knot Software Ltd.
  27 -----------------------------------------------------------------------------
  28 */
  29
  30 #include "OgreStableHeaders.h"
  31 #include "OgrePixelCountLodStrategy.h"
  32
  33 #include "OgreViewport.h"
  34
  35 #include <limits>
  36
  37 namespace Ogre {
  38     //-----------------------------------------------------------------------
  39     template<> PixelCountLodStrategy* Singleton<PixelCountLodStrategy>::ms_Singleton = 0;
  40     PixelCountLodStrategy* PixelCountLodStrategy::getSingletonPtr(void)
  41     {
  42         return ms_Singleton;
  43     }
  44     PixelCountLodStrategy& PixelCountLodStrategy::getSingleton(void)
  45     {
  46         assert( ms_Singleton );  return ( *ms_Singleton );
  47     }
  48     //-----------------------------------------------------------------------
  49     PixelCountLodStrategy::PixelCountLodStrategy()
  50         : LodStrategy("PixelCount")
  51     { }
  52     //-----------------------------------------------------------------------
  53     Real PixelCountLodStrategy::getValueImpl(const MovableObject *movableObject, const Ogre::Camera *camera) const
  54     {
  55         // Get viewport
  56         const Viewport *viewport = camera->getViewport();
  57
  58         // Get viewport area
  59         Real viewportArea = viewport->getActualWidth() * viewport->getActualHeight();
  60
  61         // Get area of unprojected circle with object bounding radius
  62         Real boundingArea = Math::PI * Math::Sqr(movableObject->getBoundingRadius());
  63
  64         // Base computation on projection type
  65         switch (camera->getProjectionType())
  66         {
  67         case PT_PERSPECTIVE:
  68             {
  69                 // Get camera distance
  70                 Real distanceSquared = movableObject->getParentNode()->getSquaredViewDepth(camera);
  71
  72                 // Check for 0 distance
  73                 if (distanceSquared <= std::numeric_limits<Real>::epsilon())
  74                     return getBaseValue();
  75
  76                 // Get projection matrix (this is done to avoid computation of tan(fov / 2))
  77                 const Matrix4& projectionMatrix = camera->getProjectionMatrix();
  78
  79                 // Estimate pixel count
  80                 return (boundingArea * viewportArea * projectionMatrix[0][0] * projectionMatrix[1][1]) / distanceSquared;
  81             }
  82         case PT_ORTHOGRAPHIC:
  83             {
  84                 // Compute orthographic area
  85                 Real orthoArea = camera->getOrthoWindowHeight() * camera->getOrthoWindowWidth();
  86
  87                 // Check for 0 orthographic area
  88                 if (orthoArea <= std::numeric_limits<Real>::epsilon())
  89                     return getBaseValue();
  90
  91                 // Estimate pixel count
  92                 return (boundingArea * viewportArea) / orthoArea;
  93             }
  94         default:
  95             {
  96                 // This case is not covered for obvious reasons
  97                 throw;
  98             }
  99         }
 100     }
 101     //---------------------------------------------------------------------
 102     Real PixelCountLodStrategy::getBaseValue() const
 103     {
 104         // Use the maximum possible value as base
 105         return std::numeric_limits<Real>::max();
 106     }
 107     //---------------------------------------------------------------------
 108     Real PixelCountLodStrategy::transformBias(Real factor) const
 109     {
 110         // No transformation required for pixel count strategy
 111         return factor;
 112     }
 113     //---------------------------------------------------------------------
 114     ushort PixelCountLodStrategy::getIndex(Real value, const Mesh::MeshLodUsageList& meshLodUsageList) const
 115     {
 116         // Values are descending
 117         return getIndexDescending(value, meshLodUsageList);
 118     }
 119     //---------------------------------------------------------------------
 120     ushort PixelCountLodStrategy::getIndex(Real value, const Material::LodValueList& materialLodValueList) const
 121     {
 122         // Values are descending
 123         return getIndexDescending(value, materialLodValueList);
 124     }
 125     //---------------------------------------------------------------------
 126     void PixelCountLodStrategy::sort(Mesh::MeshLodUsageList& meshLodUsageList) const
 127     {
 128         // Sort descending
 129         sortDescending(meshLodUsageList);
 130     }
 131     //---------------------------------------------------------------------
 132     bool PixelCountLodStrategy::isSorted(const Mesh::LodValueList& values) const
 133     {
 134         // Check if values are sorted descending
 135         return isSortedDescending(values);
 136     }
 137
 138 } // namespace