ParaPlane.h

#pragma once
// Original free version by:
// Magic Software, Inc.
// http://www.geometrictools.com/
// Copyright (c) 2000, All Rights Reserved

#include "ParaVector3.h"

namespace ParaEngine 
{
    class CShapeAABB;

    class Plane
    {
    public:
        Vector3 normal;
        float d;
        enum Side
        {
            NO_SIDE,
            POSITIVE_SIDE,
            NEGATIVE_SIDE,
            BOTH_SIDE
        };

    public:
        Plane ();
        Plane (const Plane& rhs);
        Plane (const Vector3& rkNormal, float fConstant);
        Plane (float a, float b, float c, float d);
        Plane (const Vector3& rkNormal, const Vector3& rkPoint);
        Plane (const Vector3& rkPoint0, const Vector3& rkPoint1,
            const Vector3& rkPoint2);

        Side getSide (const Vector3& rkPoint) const;

        Side getSide (const AxisAlignedBox& rkBox) const;

        Side getSide(const CShapeAABB& rkBox) const;

        Side getSide (const Vector3& centre, const Vector3& halfSize) const;

        float getDistance (const Vector3& rkPoint) const;

        void redefine(const Vector3& rkPoint0, const Vector3& rkPoint1,
            const Vector3& rkPoint2);

        void redefine(const Vector3& rkNormal, const Vector3& rkPoint);

        inline Plane&   Set(float nx, float ny, float nz, float _d){ normal.x = nx; normal.y = ny; normal.z = nz; d = _d; return *this; };
        inline Plane&   Set(const Vector3& p, const Vector3& _n){
            redefine(_n, p);
            return *this;
        }
        inline Plane&   Set(const Vector3& p0, const Vector3& p1, const Vector3& p2){
            redefine(p0, p1, p2);
            return *this;
        }

        Vector3 projectVector(const Vector3& v) const;

        float normalise(void);


        inline float PlaneDotCoord(const Vector3& pV) const 
        {
            return normal.dotProduct(pV) + d;
        }

        inline float PlaneDotNormal(const Vector3& pV) const
        {
            return normal.dotProduct(pV);
        }
        
        Plane PlaneTransform(const Matrix4& M) const;

        inline float a() const { return normal.x; };
        inline float b() const { return normal.y; };
        inline float c() const { return normal.z; };

        // Cast operators
        operator Vector3()  const;
        operator Vector4() const;

        // Arithmetic operators
        Plane   operator*(const Matrix4& m)     const;
        Plane&  operator*=(const Matrix4& m);
        Plane operator-() const;

        operator const float*() const;
        operator float*();

        bool operator==(const Plane& rhs) const
        {
            return (rhs.d == d && rhs.normal == normal);
        }
        bool operator!=(const Plane& rhs) const
        {
            return (rhs.d != d && rhs.normal != normal);
        }

        friend std::ostream& operator<< (std::ostream& o, const Plane& p);
    };

    typedef std::vector<Plane> PlaneList;

} // namespace ParaEngine