cull.h

Go to the documentation of this file.

/*! \file
  \brief  The disti::Culler class.  Implements view frustum culling.
 
  \par Copyright Information
 
  Copyright (c) 2017 by The DiSTI Corporation.<br>
  11301 Corporate Blvd; Suite 100<br>
  Orlando, Florida 32817<br>
  USA<br>
  <br>
  All rights reserved.<br>
 
  This Software contains proprietary trade secrets of DiSTI and may not be
reproduced, in whole or part, in any form, or by any means of electronic,
mechanical, or otherwise, without the written permission of DiSTI.  Said
permission may be derived through the purchase of applicable DiSTI product
licenses which detail the distribution rights of this content and any
Derivative Works based on this or other copyrighted DiSTI Software.
 
  NO WARRANTY. THE SOFTWARE IS PROVIDED "AS-IS," WITHOUT WARRANTY OF ANY KIND,
AND ANY USE OF THIS SOFTWARE PRODUCT IS AT YOUR OWN RISK. TO THE MAXIMUM EXTENT
PERMITTED BY APPLICABLE LAW, DISTI AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES
AND CONDITIONS, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES AND CONDITIONS OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE, TITLE, AND NON-INFRINGEMENT, WITH REGARD TO THE SOFTWARE.
 
  LIMITATION OF LIABILITY. TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW,
IN NO EVENT SHALL DISTI OR ITS SUPPLIERS BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
INDIRECT, OR CONSEQUENTIAL DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION,
DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS
INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR
INABILITY TO USE THE SOFTWARE, EVEN IF DISTI HAS BEEN ADVISED OF THE POSSIBILITY
OF SUCH DAMAGES.  DISTI'S ENTIRE LIABILITY AND YOUR EXCLUSIVE REMEDY SHALL NOT
EXCEED FIVE DOLLARS (US$5.00).
 
  The aforementioned terms and restrictions are governed by the laws of the
State of Florida and the United States of America.
 
*/
#ifndef _CULL_H
#define _CULL_H
 
#include "util.h"
#include "vertex.h"
 
namespace disti
{
/** The Culler class.  Implements view frustum culling. */
class Culler
{
public:
    /** Return type for culling function */
    typedef enum
    {
        OUTSIDE_FRUSTUM,    /** The object was entirely outside of the viewing frustum */
        INTERSECTS_FRUSTUM, /** The object intersects the viewing frustum */
        INSIDE_FRUSTUM      /** The object was entirely inside the viewing frustum */
    } CullResultEnum;
 
    /** Definitions for the six frustum clipping planes */
    typedef enum
    {
        RIGHT_PLANE,
        LEFT_PLANE,
        BOTTOM_PLANE,
        TOP_PLANE,
        FAR_PLANE,
        NEAR_PLANE
    } ClippingPlanesEnum;
 
protected:
    bool _enabled; ///< Whether or not culling is enabled.
 
    PlaneClass _planes[ 6 ]; ///< Array of six clipping planes to define the frustum.
 
public:
    /** Culler constructor
      * \param enabled  Whether or not to actually to the culling test
      */
    GLS_EXPORT Culler( bool enabled = true );
 
    /// Reads the current OpenGL projection matrices and determines the six frustum planes
    /// Note:  This assumes a perspective projection, but it will work with orthographic,
    /// though it could be optimized better if it was known that Ortho is being used.
    /// \param matrices A return reference for the frustum.
    GLS_EXPORT void ExtractFrustum( OpenGLMatrices& matrices );
 
    /// \param v The center of the sphere.
    /// \param radius The radius of the sphere.
    /// \return Whether the sphere is inside, outside or intersects the view frustum.
    GLS_EXPORT CullResultEnum SphereInFrustum( const Vector& v, const float radius ) const;
 
    /// Slightly faster sphere culling because it doesn't test seperately
    /// for intersection and it ignores the Enabled() state.
    /// \param center The center of the sphere.
    /// \param radius The radius of the sphere.
    /// \return True if outside or intersecting, false if inside.
    inline bool SphereOutsideFrustum( const Vector& center, const float radius ) const
    {
        if( ( _planes[ 0 ].a * center.x + _planes[ 0 ].b * center.y + _planes[ 0 ].c * center.z + _planes[ 0 ].d ) <= -radius )
            return true;
        if( ( _planes[ 1 ].a * center.x + _planes[ 1 ].b * center.y + _planes[ 1 ].c * center.z + _planes[ 1 ].d ) <= -radius )
            return true;
        if( ( _planes[ 2 ].a * center.x + _planes[ 2 ].b * center.y + _planes[ 2 ].c * center.z + _planes[ 2 ].d ) <= -radius )
            return true;
        if( ( _planes[ 3 ].a * center.x + _planes[ 3 ].b * center.y + _planes[ 3 ].c * center.z + _planes[ 3 ].d ) <= -radius )
            return true;
        if( ( _planes[ 4 ].a * center.x + _planes[ 4 ].b * center.y + _planes[ 4 ].c * center.z + _planes[ 4 ].d ) <= -radius )
            return true;
        if( ( _planes[ 5 ].a * center.x + _planes[ 5 ].b * center.y + _planes[ 5 ].c * center.z + _planes[ 5 ].d ) <= -radius )
            return true;
 
        return false; // inside (or intersecting)
    }
 
    /** Accessor method to get whether or not culling is enabled
      * \return Whether or not culling is enabled
      */
    inline bool Enabled() const { return _enabled; }
 
    /// Accessor method to set whether or not culling is enabled.
    /// Be careful with this, because the Culler is usually passed by reference.
    /// \param newVal The enabled value to set.
    inline void Enabled( bool newVal ) { _enabled = newVal; }
 
    /// Returns the clip plane values for the desired plane index.
    /// \param whichPlane The index for the clipping plane to return.
    /// \return A reference to the desired clipping plane for this view frustum.
    GLS_EXPORT const PlaneClass& Plane( const ClippingPlanesEnum& whichPlane ) const;
};
 
} // namespace disti
 
#endif