source: GTP/trunk/App/Games/Jungle_Rumble/src/physic/foundation/include/NxPlane.h @ 1378

#ifndef NX_FOUNDATION_NXPLANE
#define NX_FOUNDATION_NXPLANE
/*----------------------------------------------------------------------------*\
|
|                                               Public Interface to NovodeX Technology
|
|                                                            www.novodex.com
|
\*----------------------------------------------------------------------------*/
/** \addtogroup foundation
  @{
*/

#include "Nxf.h"
#include "NxVec3.h"
#include "NxMat34.h"

/**
\brief Representation of a plane.

 Plane equation used: a*x + b*y + c*z + d = 0
*/
class NxPlane
        {
        public:
        /**
        \brief Constructor
        */
        NX_INLINE NxPlane()
                {
                }

        /**
        \brief Constructor from a normal and a distance
        */
        NX_INLINE NxPlane(NxF32 nx, NxF32 ny, NxF32 nz, NxF32 d)
                {
                set(nx, ny, nz, d);
                }

        /**
        \brief Constructor from a point on the plane and a normal
        */
        NX_INLINE NxPlane(const NxVec3& p, const NxVec3& n)
                {
                set(p, n);
                }

        /**
        \brief Constructor from three points
        */
        NX_INLINE NxPlane(const NxVec3& p0, const NxVec3& p1, const NxVec3& p2)
                {
                set(p0, p1, p2);
                }

        /**
        \brief Constructor from a normal and a distance
        */
        NX_INLINE NxPlane(const NxVec3& _n, NxF32 _d) : normal(_n), d(_d)
                {
                }

        /**
        \brief Copy constructor
        */
        NX_INLINE NxPlane(const NxPlane& plane) : normal(plane.normal), d(plane.d)
                {
                }

        /**
        \brief Destructor
        */
        NX_INLINE ~NxPlane()
                {
                }

        /**
        \brief Sets plane to zero.
        */
        NX_INLINE NxPlane& zero()
                {
                normal.zero();
                d = 0.0f;
                return *this;
                }

        NX_INLINE NxPlane& set(NxF32 nx, NxF32 ny, NxF32 nz, NxF32 _d)
                {
                normal.set(nx, ny, nz);
                d = _d;
                return *this;
                }

        NX_INLINE NxPlane& set(const NxVec3& _normal, NxF32 _d)
                {
                normal = _normal;
                d = _d;
                return *this;
                }

        NX_INLINE NxPlane& set(const NxVec3& p, const NxVec3& _n)
                {
                normal = _n;
                // Plane equation: a*x + b*y + c*z + d = 0
                // p belongs to plane so:
                //     a*p.x + b*p.y + c*p.z + d = 0
                // <=> (n|p) + d = 0
                // <=> d = - (n|p)
                d = - p.dot(_n);
                return *this;
                }

        /**
         \brief Computes the plane equation from 3 points.
         */
        NxPlane& set(const NxVec3& p0, const NxVec3& p1, const NxVec3& p2)
                {
                NxVec3 Edge0 = p1 - p0;
                NxVec3 Edge1 = p2 - p0;

                normal = Edge0.cross(Edge1);
                normal.normalize();

                // See comments in set() for computation of d
                d = -p0.dot(normal);

                return  *this;
                }

        NX_INLINE NxF32 distance(const NxVec3& p) const
                {
                // Valid for plane equation a*x + b*y + c*z + d = 0
                return p.dot(normal) + d;
                }

        NX_INLINE bool belongs(const NxVec3& p) const
                {
                return fabsf(distance(p)) < (1.0e-7f);
                }

        /**
        \brief projects p into the plane
        */
        NX_INLINE NxVec3 project(const NxVec3 & p) const
                {
                // Pretend p is on positive side of plane, i.e. plane.distance(p)>0.
                // To project the point we have to go in a direction opposed to plane's normal, i.e.:
                return p - normal * distance(p);
//              return p + normal * distance(p);
                }

        /**
        \brief find an arbitrary point in the plane
        */
        NX_INLINE NxVec3 pointInPlane() const
                {
                // Project origin (0,0,0) to plane:
                // (0) - normal * distance(0) = - normal * ((p|(0)) + d) = -normal*d
                return - normal * d;
//              return normal * d;
                }

        NX_INLINE void normalize()
                {
                        NxF32 Denom = 1.0f / normal.magnitude();
                        normal.x        *= Denom;
                        normal.y        *= Denom;
                        normal.z        *= Denom;
                        d                       *= Denom;
                }

        NX_INLINE operator NxVec3() const
                {
                return normal;
                }

        NX_INLINE void transform(const NxMat34 & transform, NxPlane & transformed) const
                {
                transformed.normal = transform.M * normal;
                transformed.d = d - (transform.t | transformed.normal);
                }

        NX_INLINE void inverseTransform(const NxMat34 & transform, NxPlane & transformed) const
                {
                transformed.normal = transform.M % normal;
                NxVec3 it = transform.M %  transform.t;
                transformed.d = d + (it | transformed.normal);
                }

        NxVec3  normal;         //!< The normal to the plane
        NxF32   d;                      //!< The distance from the origin
        };

 /** @} */
#endif


//AGCOPYRIGHTBEGIN
///////////////////////////////////////////////////////////////////////////
// Copyright © 2005 AGEIA Technologies.
// All rights reserved. www.ageia.com
///////////////////////////////////////////////////////////////////////////
//AGCOPYRIGHTEND