D:/Zythum/DinoKod/Common/Plane.h

#ifndef __PLANE_H__
#define __PLANE_H__

#include "Common/CommonDll.h"
#include "Common/Types.h"

//---------------------------------------------------------------------------------------------------------------------
typedef enum _KPPOINTSIDE
{
        KPPS_FRONTSIDE,
        KPPS_BACKSIDE,
        KPPS_ONPLANE
} KPPOINTSIDE;

//---------------------------------------------------------------------------------------------------------------------
class COMMON_API KPlane
{
public:
        KVector         m_Normal;
        float           m_Distance;

        inline KPlane()
        {
                // m_Vector est deja initialisé par KVector::KVector()
                m_Distance = 0.0f;
        }
        
        inline KPlane( KVector& Normal, float Distance )
        {
                m_Normal        = Normal;
                m_Normal.Normalize();
                m_Distance      = Distance;
        }

        inline KPlane( KVector& Origin, KVector& Normal )
        {
                m_Normal        = Normal;
                m_Normal.Normalize();
                m_Distance = -KVector::DotProduct( Origin, m_Normal );
        }

        inline KPlane( KVector& Vector0, KVector& Vector1, KVector& Vector2 )
        {
                m_Normal = KVector::CrossProduct( Vector1 - Vector0, Vector2 - Vector0 );
                m_Normal.Normalize();
                m_Distance = -KVector::DotProduct( Vector0, m_Normal );
        }

        inline float Distance( KVector& Vector )
        {
                return KVector::DotProduct( m_Normal, Vector ) - m_Distance;
        }

        inline void Normalize()
        {
                float   Magnitude = m_Normal.Magnitude();

                m_Normal.x /= Magnitude;
                m_Normal.y /= Magnitude;
                m_Normal.z /= Magnitude;
                m_Distance /= Magnitude;
        }

        inline KPPOINTSIDE GetPointSide( KVector& Point, float Epsilon = 0.001f )
        {
                float Det = Distance( Point );

                if( Det < -Epsilon )
                        return KPPS_BACKSIDE;

                if( Det > Epsilon )
                        return KPPS_FRONTSIDE;

                return KPPS_ONPLANE;
        }       

        inline bool IsFrontFacingTo( KVector& Direction )
        {
                return ( m_Normal.DotProduct( Direction ) <= 0 );
        }

        inline double SignedDistanceTo( KVector& Point )
        {
                return Point.DotProduct( m_Normal ) + m_Distance;
        }

        inline static bool IsBBoxInside( KPlane* pClipPlane, u32 nClipPlanes, KVector pBBox[6] )
        {
                bool    bInside;
/*
                for( u32 b = 0; b < 6; b ++ )
                {
                        bInside = true;
                        for( u32 p = 0; p < nClipPlanes; p ++ )
                        {
                                // teste si le point est du bon coté du plan
                                if( pClipPlane[p].Distance( pBBox[b] ) < 0.0f )
                                {
                                        // le point est en dehors
                                        bInside = false;
                                        break;
                                }
                        }
                
                        if( bInside )
                                return true;
                }
                */

                for( u32 p = 0; p < nClipPlanes; p ++ )
                {
                        bInside = false;
                        
                        // teste si le point est du bon coté du plan
                        for( u32 b = 0; b < 8; b ++ )
                        {
                                if( pClipPlane[p].Distance( pBBox[b] ) > 0.0f )
                                {
                                        // le point est dedans
                                        bInside = true;
                                        break;
                                }
                        }
                        if( !bInside )
                                return false;
                }

                return true;
        }
};

#endif //       __PLANE_H__

---