Adding functionality to TPlane.

Engine/src/Runtime/Core/public/Math/MathFwd.h

@@ -30,6 +30,7 @@ namespace Phanes::Core::Math {
     template<RealType T>			struct TVector3;
     template<RealType T>			struct TVector4;
     template<RealType T>			struct TRay;
+    template<RealType T>			struct TLine;
     template<RealType T>			struct TPlane;
     template<RealType T>			struct TMatrix2;
     template<RealType T>			struct TMatrix3;
@@ -96,6 +97,15 @@ namespace Phanes::Core::Math {
     typedef std::vector<Matrix3>		Matrix3List;
     typedef std::vector<Matrix3d>		Matrix3Listd;
 
+
+    // TPlane
+    typedef TPlane<float>               Plane;
+    typedef TPlane<double>              Planed;
+
+    typedef std::vector<Plane>		    PlaneList;
+    typedef std::vector<Planed>		    PlaneListd;
+    
+
 } // Phanes::Core::Math::coretypes
 
 namespace Phanes::Core::Math::Internal

Engine/src/Runtime/Core/public/Math/Plane.hpp

@@ -1,8 +1,12 @@
 #pragma once
 
+
+// TODO: Transform
+
 #include "Core/public/Math/Boilerplate.h"
 #include "Core/public/Math/MathFwd.h"
 
+#include "Core/public/Math/Line.hpp"
 #include "Core/public/Math/Vector3.hpp"
 
 namespace Phanes::Core::Math {
@@ -13,8 +17,31 @@ namespace Phanes::Core::Math {
     struct TPlane
     {
     public:
-        TVector3<T> normal;
+        using Real = T;
-        T d;
+
+        union
+        {
+            struct
+            {
+                /** X Part of the normal. */
+                Real x;
+                
+                /** Y Part of the normal. */
+                Real y;
+
+                /** Z Part of the normal. */
+                Real z;
+            };
+
+            TVector3<Real> normal;
+        };
+
+        /** Scalar component of plane. */
+        union 
+        {
+            Real d;
+            Real w;
+        };
         
     public:
 
@@ -28,13 +55,13 @@ namespace Phanes::Core::Math {
          * Copy constructor
          */
 
-        TPlane(const TPlane<T>& plane) : normal(plane.normal), d(plane.d) {};
+        TPlane(const TPlane<Real>& plane) : normal(plane.normal), d(plane.d) {};
 
         /**
          * Move constructor 
          */
 
-        TPlane(TPlane<T>&& plane) :
+        TPlane(TPlane<Real>&& plane) :
             normal(std::move(plane.normal)),
             d(std::move(plane.d))
         {}
@@ -49,7 +76,7 @@ namespace Phanes::Core::Math {
          * @note Normal is NOT normalized, make sure to normalize [PARAM]normal, or use [FUNC]CreateFromVector. Otherwise unexpected results may occur using the plane.
          */
         
-        TPlane(const TVector3<T>& normal, T d) :
+        TPlane(const TVector3<Real>& normal, Real d) :
             normal(normal),
             d(d)
         {}
@@ -61,7 +88,7 @@ namespace Phanes::Core::Math {
          * @param(base) Base point
          */
        
-        TPlane(const TVector3<T>& normal, const TVector3<T>& base) :
+        TPlane(const TVector3<Real>& normal, const TVector3<Real>& base) :
             normal(normal)
         {
             this->d = DotP(this->normal, base);
@@ -76,10 +103,10 @@ namespace Phanes::Core::Math {
          * @param(d) D coefficient
          */
 
-        TPlane(T x, T y, T z, T d) :
+        TPlane(Real x, Real y, Real z, Real d) :
             d(d)
         {
-            this->normal = TVector3<T>(x, y, z);
+            this->normal = TVector3<Real>(x, y, z);
         }
 
         /**
@@ -90,13 +117,380 @@ namespace Phanes::Core::Math {
          * @param(p3) Point three
          */
 
-        TPlane(const TVector3<T>& p1, const TVector3<T>& p2, const TVector3<T>& p3)
+        TPlane(const TVector3<Real>& p1, const TVector3<Real>& p2, const TVector3<Real>& p3)
         {
             this->normal = Normalize(CrossP(p1, p2));
             this->d = DotP(this->normal, p3);
         }
     };
 
+
+    // ======================== //
+    //   Operators for TPlane   //
+    // ======================== //
+
+
+    /**
+     * Adds pl2 to pl1.
+     * 
+     * @param(pl1) Plane to add to
+     * @param(pl2) Plane to add
+     *
+     * @note This leads to the plane not being normalized anymore. Use PlaneNormalizeV to normalize again.
+     * @see [FUNC] PlaneNormalizeV
+     */
+
+    template<RealType T>
+    TPlane<T> operator+= (TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        pl1.normal += pl2.normal; pl1.d += pl2.d;
+
+        return pl1;
+    }
+
+    /**
+     * Substracts pl2 from pl1.
+     *
+     * @param(pl1) Plane to substract from
+     * @param(pl2) Plane to substract
+     *
+     * @note This leads to the plane not being normalized anymore. Use PlaneNormalizeV to normalize again.
+     * @see [FUNC] PlaneNormalizeV
+     */
+
+    template<RealType T>
+    TPlane<T> operator-= (TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        pl1.normal -= pl2.normal; pl1.d -= pl2.d;
+
+        return pl1;
+    }
+
+    /**
+     * Multiplies pl1 with pl2.
+     *
+     * @param(pl1) Plane to multiply
+     * @param(pl2) Plane to multiply with
+     *
+     * @note This leads to the plane not being normalized anymore. Use PlaneNormalizeV to normalize again.
+     * @see [FUNC] PlaneNormalizeV
+     */
+
+    template<RealType T>
+    TPlane<T> operator*= (TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        pl1.x *= pl2.x; pl1.y *= pl2.y; pl1.z *= pl2.z; pl1.d *= pl2.d;
+
+        return pl1;
+    }
+
+    /**
+     * Multiplies pl1 with a scalar
+     *
+     * @param(pl1) Plane to multiply
+     * @param(s) Scalar to multiply with
+     */
+
+    template<RealType T>
+    TPlane<T> operator*= (TPlane<T>& pl1, T s)
+    {
+        pl1.normal *= s; pl1 *= s;
+
+        return pl1;
+    }
+
+    /**
+     * Divides pl1 with a scalar
+     *
+     * @param(pl1) Plane to divide
+     * @param(s) Scalar to divide with
+     */
+
+    template<RealType T>
+    TPlane<T> operator/= (TPlane<T>& pl1, T s)
+    {
+        T _1_s = (T)1.0 / s;
+
+        pl1.normal *= _1_s; pl1 *= _1_s;
+
+        return pl1;
+    }
+
+
+    /**
+     * Add two planes.
+     *
+     * @param(pl1) Plane
+     * @param(pl2) Plane
+     *
+     * @return Sum of planes
+     */
+
+    template<RealType T>
+    TPlane<T> operator+ (const TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        return TPlane<T>(pl1.normal + pl2.normal, pl1.d + pl2.d);
+    }
+
+    /**
+     * Substracts two planes.
+     *
+     * @param(pl1) Plane
+     * @param(pl2) Plane 
+     *
+     * @return Difference of the planes
+     */
+
+    template<RealType T>
+    TPlane<T> operator- (const TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        return TPlane<T>(pl1.normal - pl2.normal, pl1.d - pl2.d);
+    }
+
+    /**
+     * Multiplies two planes.
+     *
+     * @param(pl1) Plane 
+     * @param(pl2) Plane
+     *
+     * @return Product of planes
+     */
+
+    template<RealType T>
+    TPlane<T> operator* (const TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        return TPlane<T>(pl1.x * pl2.x, pl1.y * pl2.y, pl1.z * pl2.z, pl1.d * pl2.d);
+    }
+
+    /**
+     * Multiplies pl1 with a scalar
+     *
+     * @param(pl1) Plane to multiply
+     * @param(s) Scalar to multiply with
+     * 
+     * @return Product of plane and scalar
+     */
+
+    template<RealType T>
+    TPlane<T> operator*= (const TPlane<T>& pl1, T s)
+    {
+        return TPlane<T>(pl1.normal * s, pl1.d * s);
+    }
+
+    /**
+     * Divides pl1 with a scalar
+     *
+     * @param(pl1) Plane to divide
+     * @param(s) Scalar to divide with
+     * 
+     * @return Quotient of plane and scalar
+     */
+
+    template<RealType T>
+    TPlane<T> operator/= (const TPlane<T>& pl1, T s)
+    {
+        T _1_s = (T)1.0 / s;
+
+        return TPlane<T>(pl1.normal * _1_s, pl1.d * _1_s);
+    }
+
+    /**
+     * Tests two planes for equality
+     * 
+     * @see [FUNC] Equals
+     * 
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * 
+     * @return True, if planes are equal, false, if not.
+     */
+
+    template<RealType T>
+    bool operator== (const TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        return pl1.normal == pl2.normal && abs(pl1.d - pl2.d) < P_FLT_INAC;
+    }
+
+    /**
+     * Tests two planes for inequality
+     *
+     * @see [FUNC] Equals
+     *
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     *
+     * @return True, if planes are inequal, false, if not.
+     */
+
+    template<RealType T>
+    bool operator!= (const TPlane<T>& pl1, const TPlane<T>& pl2)
+    {
+        return pl1.normal != pl2.normal || abs(pl1.d - pl2.d) >= P_FLT_INAC;
+    }
+
+
+    // ======================= //
+    //   Functions of TPlane   //
+    // ======================= //
+
+
+
+
+    /**
+     * Tests whether two planes are perpendicular.
+     *
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * @param(threshold) Allowed T inaccuracy
+     *
+     * @return True if perpendicular, false if not.
+     */
+
+    template<RealType T>
+    inline bool IsPerpendicular(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = P_FLT_INAC)
+    {
+        return (abs(DotP(pl1.normal, pl2.normal)) < threshold);
+    }
+
+    /**
+     * Tests whether two planes are parallel.
+     *
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f)
+     *
+     * @return True if parallel, false if not.
+     */
+
+    template<RealType T>
+    inline bool IsParallel(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = 1.0f - P_FLT_INAC)
+    {
+        return (abs(DotP(pl1.normal, pl2.normal)) > threshold);
+    }
+
+    /**
+     * Tests whether two planes are coincident (Parallel and point in same direction).
+     *
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f)
+     *
+     * @return True if coincident, false if not.
+     */
+
+    template<RealType T>
+    inline bool IsCoincident(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = 1.0f - P_FLT_INAC)
+    {
+        return (DotP(pl1.normal, pl2.normal) > threshold);
+    }
+
+    /**
+     * Tests whether pl1 plane is a unit vector.
+     *
+     * @param(pl1) Plane
+     * @param(threshold) Allowed T inaccuracy
+     *
+     * @return True if unit vector, false if not.
+     */
+
+    template<RealType T>
+    inline bool IsNormalized(const TPlane<T>& pl1, T threshold = P_FLT_INAC)
+    {
+        return (SqrMagnitude(pl1.normal) < threshold);
+    }
+
+    /**
+     * Tests whether two planes are the same
+     * 
+     * @see [FUNC]Equals
+     * 
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * @param(threshold) Allowed T inaccuracy
+     * 
+     * @return True if same, false if not.
+     * @note Planes must be normalized.
+     */
+
+    template<RealType T>
+    inline bool IsSame(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = P_FLT_INAC)
+    {
+
+        return DotP(pl1.normal, pl2.normal) > threshold && abs(pl1.d - pl2.d) < P_FLT_INAC;
+    }
+
+    /** 
+     * Normalizes plane.
+     * 
+     * @param(pl1) Plane
+     */
+
+    template<RealType T>
+    TPlane<T> PlaneNormalizeV(TPlane<T>& pl1)
+    {
+        T normVec = SqrMagnitude(pl1);
+
+        T scale = (normVec > P_FLT_INAC) ? (T)1.0 / sqrt(normVec) : 1.0f;
+
+        pl1.normal *= scale; pl1.d *= scale;
+
+        return pl1;
+    }
+
+    /**
+     * Normalizes plane.
+     *
+     * @param(pl1) Plane
+     * 
+     * @return Normalized plane
+     */
+
+    template<RealType T>
+    TPlane<T> PlaneNormalize(TPlane<T>& pl1)
+    {
+        T normVec = SqrMagnitude(pl1);
+
+        T scale = (normVec > P_FLT_INAC) ? (T)1.0 / sqrt(normVec) : 1.0f;
+
+        return TPlane<T>(pl1.normal * scale, pl1.d * scale);
+    }
+
+    /**
+     * Normalizes plane.
+     *
+     * @param(pl1) Plane
+     * 
+     * @note Does not check for zero vector pl1.normal.
+     */
+
+    template<RealType T>
+    TPlane<T> PlaneUnsafeNormalizeV(TPlane<T>& pl1)
+    {
+        T scale = (T)1.0 / Magnitude(pl1);
+
+        pl1.normal *= scale; pl1.d *= scale;
+
+        return pl1;
+    }
+
+    /**
+     * Normalizes plane.
+     *
+     * @param(pl1) Plane
+     *
+     * @return Normalized plane
+     * 
+     * @note Does not check for zero vector pl1.normal.
+     */
+
+    template<RealType T>
+    TPlane<T> PlaneUnsafeNormalize(TPlane<T>& pl1)
+    {
+        T scale = (T)1.0 / Magnitude(pl1);
+
+        return TPlane<T>(pl1.normal * scale, pl1.d * scale);
+    }
+
     /**
      * Get dot product between two planes
      * 
@@ -193,6 +587,80 @@ namespace Phanes::Core::Math {
         // TODO: Do with operator*
     }
 
+    /**
+     * Calculates distance bewteen point and plane.
+     * 
+     * @param(pl1) Plane
+     * @param(p1) Point
+     * 
+     * @return Distance from point to plane
+     * @note Distance is 0 if point is on plane, >0 if it's in front and <0 if it's on the backside.
+     */
+
+    template<RealType T>
+    T PointDistance(const TPlane<T>& pl1, const TVector3<T>& p1)
+    {
+        return (pl1.x * p1.x + pl1.y * p1.y + pl1.z * p1.z) - pl1.d;
+    }
+
+    /**
+     * Gets the origin point (base) of the plane
+     * 
+     * @param(pl1) Plane
+     * 
+     * @return Base of plane
+     */
+
+    template<RealType T>
+    TVector3<T> GetOrigin(const TPlane<T>& pl1)
+    {
+        return TVector3<T>(pl1.normal * d);
+    }
+
+    /**
+     * Translates plane by vector
+     *
+     * @param(pl1) Plane
+     * @param(v1) Vector
+     */
+
+    template<RealType T>
+    TPlane<T> TranslateV(TPlane<T>& pl1, const TVector3<T>& v1)
+    {
+        
+        pl1.d = DotP(this->normal, GetOrigin(pl1) + v1);
+
+        return pl1;
+    }
+
+    /**
+     * Translates plane by vector
+     *
+     * @param(pl1) Plane
+     * @param(v1) Vector
+     */
+
+    template<RealType T>
+    TPlane<T> Translate(TPlane<T>& pl1, const TVector3<T>& v1)
+    {
+        return TPlane<T>(pl1.normal, GetOrigin(pl1) + v1);
+    }
+
+    /**
+     * Returns the side a point is on.
+     * 
+     * @param(pl1) Plane
+     * @param(p1) Point
+     * 
+     * @return True, if it's in the front and false, if it's on the back.
+     */
+
+    template<RealType T>
+    bool GetSide(const TPlane<T>& pl1, const TVector3<T>& p1)
+    {
+        return (pl1.d <= DotP(pl1.normal, p1));
+    }
+
     /**
      * Projects vector onto plane
      *
@@ -227,7 +695,7 @@ namespace Phanes::Core::Math {
     }
 
     /**
-     * Reflect by plane
+     * Reflect from plane
      *
      * @param(v1) Vector to mirror
      * @param(plane) Plane to mirror on
@@ -241,6 +709,21 @@ namespace Phanes::Core::Math {
         return ReflectV(v1, plane.normal);
     }
 
+    /**
+     * Reflect from plane
+     *
+     * @param(v1) Vector to mirror
+     * @param(normal) Normal of plane
+     *
+     * @note result is stored in v1.
+     */
+
+    template<RealType T>
+    FORCEINLINE TVector3<T> ReflectFromPlaneV(TVector3<T>& v1, const TVector3<T>& normal)
+    {
+        return ReflectV(v1, normal);
+    }
+
 
     /**
      * Reflect from plane
@@ -305,6 +788,77 @@ namespace Phanes::Core::Math {
         return Reject(v1, plane.normal);
     }
 
+    /**
+     * Tests planes for equality
+     * 
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * @param(threshold) Allowed inaccuracy
+     * 
+     * @return True, if equal, false if not.
+     */
+
+    template<RealType T>
+    inline bool Equals(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = P_FLT_INAC)
+    {
+        return Equals(pl1.normal, pl2.normal, threshold) && abs(pl1.d - pl2.d) < threshold;
+    }
+
+
+
+    /**
+     * Tests whether two planes intersect. Sets line to intersection-line if true.
+     * 
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * @param(interLine) Line of intersection
+     * @param(threshold) Threshold for parallel planes.
+     * 
+     * @return True, if planes intersect, false, if not.
+     */
+
+    template<RealType T>
+    inline bool PlanesIntersect(const TPlane<T>& pl1, const TPlane<T>& pl2, Ref<TLine<T>> interLine, T threshold = P_FLT_INAC)
+    {
+        TVector3<T> dirLine = CrossP(pl1.normal, pl2.normal);
+        T det = SqrMagnitude(dirLine);
+
+        if (abs(det) > P_FLT_INAC)
+        {
+            interLine = MakeRef<TLine<T>(dirLine, (CrossP(dirLine, pl2.normal) * pl1.d + CrossP(dirLine, pl1.normal) * pl2.d) / det);
+            return true;
+        }
+        
+        return false;
+    }
+
+    /**
+     * Tests whether three planes intersect. Sets line to intersection-line if true.
+     *
+     * @param(pl1) Plane one
+     * @param(pl2) Plane two
+     * @param(pl3) Plane three
+     * @param(interPoint) Point of intersection
+     * @param(threshold) Threshold for parallel planes.
+     *
+     * @return True, if all planes intersect, false, if not.
+     */
+
+    template<RealType T>
+    inline bool PlanesIntersect(const TPlane<T>& pl1, const TPlane<T>& pl2, const TPlane<T>& pl3, Ref<TVector3<T>> interPoint, T threshold = P_FLT_INAC)
+    {
+        T det = DotP(CrossP(pl1.normal, pl2.normal), pl3.normal);
+
+        if (abs(det) > P_FLT_INAC)
+        {
+            interPoint = MakeRef<TVector3<T>>((CrossP(pl3.normal, pl2.normal) * pl1.d + CrossP(pl1.normal, pl3.normal) * pl2.d) / det);
+            return true;
+        }
+
+        return false;
+    }
+
+
 } // Phanes::Core::Math