Plane3f.h

Go to the documentation of this file.

// Copyright NVIDIA Corporation 2002-2004
// TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
// *AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
// OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL NVIDIA 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 THIS SOFTWARE, EVEN IF NVIDIA HAS
// BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 

#pragma once

#include "nvsgcommon.h"

#include "nvmath/nvmath.h"
#include "nvmath/Vec3f.h"

namespace nvmath
{
  class Plane3f
  {
    public:

      NVSG_API Plane3f( void );

      NVSG_API Plane3f( const Vec3f &n  
                      , float c         
                      );

      NVSG_API Plane3f( const Vec3f &n  
                      , const Vec3f &p  
                      );

      NVSG_API Plane3f( const Vec3f &p0 
                      , const Vec3f &p1 
                      , const Vec3f &p2 
                      );


      NVSG_API Plane3f operator-( void ) const;


      NVSG_API Plane3f & operator=( const Plane3f &pl 
                                  );


      NVSG_API bool operator==( const Plane3f& pl     
                              ) const;


      NVSG_API bool operator!=( const Plane3f& pl     
                              ) const;


      NVSG_API float operator()( const Vec3f &p       
                               ) const;


      NVSG_API Vec3f & n( void );


      NVSG_API const Vec3f & n( void ) const;


      NVSG_API float & c( void );


      NVSG_API const float & c( void ) const;

    private:
      Vec3f m_normal;
      float m_offset;
  };

  // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // non-member functions
  // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  inline bool areOnOppositeSides( const Plane3f &plane    
                                , const Vec3f &p0         
                                , const Vec3f &p1         
                                )
  {
    return( plane( p0 ) * plane( p1 ) < 0 );
  }

  inline bool areOnSameSide( const Plane3f &plane    
                           , const Vec3f &p0         
                           , const Vec3f &p1         
                           )
  {
    return( plane( p0 ) * plane( p1 ) > 0 );
  }

  inline float signedDistance( const Plane3f &pl   
                             , const Vec3f &p      
                             )
  {
    return( pl( p ) );
  }

  inline float distance( const Plane3f &pl   
                       , const Vec3f &p      
                       )
  {
    return( fabsf( pl( p ) ) );
  }

  inline Vec3f nearestPoint( const Plane3f &pl  
                           , const Vec3f &p     
                           )
  {
    return( p - pl( p ) * pl.n() );
  }

  // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  // inlines
  // - - - - -  - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
  inline Plane3f::Plane3f( void )
  {
  }

  inline Plane3f::Plane3f( const Vec3f &n, float c )
    : m_normal(n)
    , m_offset(c)
  {
    __ASSERT( isNormalized( m_normal ) );
  }

  inline Plane3f::Plane3f( const Vec3f &n, const Vec3f &p )
    : m_normal(n)
    , m_offset(-p*n)
  {
    __ASSERT( isNormalized( m_normal ) );
  }

  inline Plane3f::Plane3f( const Vec3f &p0, const Vec3f &p1, const Vec3f &p2 )
  {
    __ASSERT( ( p0 != p1 ) && ( p0 != p2 ) && ( p1 != p2 ) );
    m_normal = normalize( ( p1 - p0 ) ^ ( p2 - p0 ) );
    m_offset = - m_normal * p0;
  }

  inline Plane3f Plane3f::operator-( void ) const
  {
    return( Plane3f( -m_normal, -m_offset ) );
  }

  inline Plane3f & Plane3f::operator=( const Plane3f &pl )
  {
    m_normal = pl.n();
    m_offset = pl.c();
    return( *this );
  }

  inline bool Plane3f::operator==( const Plane3f &pl ) const
  {
    return( m_normal == pl.n() && ( fabsf( m_offset - pl.c() ) < FLT_EPSILON ) );
  }

  inline bool Plane3f::operator!=( const Plane3f &pl ) const
  {
    return( ! (this->operator==( pl )) );
  }

  inline Vec3f & Plane3f::n( void )
  {
    return( m_normal );
  }

  inline const Vec3f & Plane3f::n( void ) const
  {
    return( m_normal );
  }

  inline float & Plane3f::c( void )
  {
    return( m_offset );
  }

  inline const float & Plane3f::c( void ) const
  {
    return( m_offset );
  }

} // end namspace nvmath

---