thoehne/PhanesEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

SIMD imporvements

Browse Source
This commit is contained in:
THoehne 2024-08-27 13:26:28 +02:00
parent 84c6b0b753
commit 8e581571b4
3 changed files with 455 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
Engine/Source/Runtime/Core/public/Math/Detail/PlaneDecl.inl Normal file
View File

@ -0,0 +1,116 @@
#pragma once
#include "Core/public/Math/Boilerplate.h"
namespace Phanes::Core::Math::Detail
{
template<RealType T, bool S>
struct construct_plane {};
template<RealType T, bool S>
struct compute_plane_add {};
template<RealType T, bool S>
struct compute_plane_sub {};
template<RealType T, bool S>
struct compute_plane_mul {};
template<RealType T, bool S>
struct compute_plane_div {};
template<RealType T>
struct construct_plane<T, false>
{
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1)
{
r.comp = std::copy(pl1.comp);
}
static constexpr void map(TPlane<T, false>& r, TPlane<T, false>&& pl1)
{
r.comp = std::move(pl1.comp);
}
static constexpr void map(TPlane<T, false>& r, const TVector3<T, false>& normal, T d)
{
r.normal = normal;
r.d = d;
}
static constexpr void map(TPlane<T, false>& r, const TVector3<T, false>& normal, const TVector3<T, false>& base)
{
r.normal = std::copy(normal);
r.d = DotP(r.normal, base);
}
static constexpr void map(TPlane<T, false>& r, T x, T y, T z, T d)
{
r.normal = TVector3<T, false>(x, y, z);
r.d = d;
}
static constexpr void map(TPlane<T, false>& r, const TVector3<T, false>& v1, const TVector3<T, false>& v2, const TVector3<T, false>& v3)
{
r.normal = Normalize(CrossP(v1, v2));
r.d = DotP(r.normal, v3);
}
};
template<RealType T>
struct compute_plane_add<T, false>
{
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{
r.comp = pl1.comp + pl2.comp;
}
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, T s)
{
r.comp = pl1.comp + s;
}
};
template<RealType T>
struct compute_plane_sub<T, false>
{
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{
r.comp = pl1.comp - pl2.comp;
}
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, T s)
{
r.comp = pl1.comp - s;
}
};
template<RealType T>
struct compute_plane_mul<T, false>
{
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{
r.comp = pl1.comp * pl2.comp;
}
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, T s)
{
r.comp = pl1.comp * s;
}
};
template<RealType T>
struct compute_plane_div<T, false>
{
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{
r.comp = pl1.comp / pl2.comp;
}
static constexpr void map(TPlane<T, false>& r, const TPlane<T, false>& pl1, T s)
{
r.comp = pl1.comp / s;
}
};
}

309
Engine/Source/Runtime/Core/public/Math/Plane.hpp
View File

@ -14,12 +14,16 @@ namespace Phanes::Core::Math {
// Plane in 3D space, defined as: P: ax + by + cz = d; // Plane in 3D space, defined as: P: ax + by + cz = d;
template<RealType T> template<RealType T, bool S>
struct TPlane struct TPlane
{ {
public: public:
using Real = T; using Real = T;
union
{
struct
{
union union
{ {
struct struct
@ -34,14 +38,20 @@ namespace Phanes::Core::Math {
Real z; Real z;
}; };
TVector3<Real> normal; TVector3<Real, S> normal;
}; };
/** Scalar component of plane. */ /// <summary>
union /// Scalar component of plane
{ /// </summary>
Real d; Real d;
Real w; };
/// <summary>
/// Vector containing all components of vector (x, y, z and d).
/// </summary>
TVector4<Real, S> comp;
}; };
public: public:
@ -56,16 +66,13 @@ namespace Phanes::Core::Math {
* Copy constructor * Copy constructor
*/ */
TPlane(const TPlane<Real>& plane) : normal(plane.normal), d(plane.d) {}; TPlane(const TPlane<Real, S>& plane);
/** /**
* Move constructor * Move constructor
*/ */
TPlane(TPlane<Real>&& plane) : TPlane(TPlane<Real, S>&& plane);
normal(std::move(plane.normal)),
d(std::move(plane.d))
{}
/** /**
@ -77,10 +84,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. * @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<Real>& normal, Real d) : TPlane(const TVector3<Real, S>& normal, Real d);
normal(normal),
d(d)
{}
/** /**
* Construct plane from normal and base point. * Construct plane from normal and base point.
@ -89,11 +93,7 @@ namespace Phanes::Core::Math {
* @param(base) Base point * @param(base) Base point
*/ */
TPlane(const TVector3<Real>& normal, const TVector3<Real>& base) : TPlane(const TVector3<Real, S>& normal, const TVector3<Real, S>& base);
normal(normal)
{
this->d = DotP(this->normal, base);
}
/** /**
* Construct plane from coefficients * Construct plane from coefficients
@ -104,11 +104,7 @@ namespace Phanes::Core::Math {
* @param(d) D coefficient * @param(d) D coefficient
*/ */
TPlane(Real x, Real y, Real z, Real d) : TPlane(Real x, Real y, Real z, Real d);
d(d)
{
this->normal = TVector3<Real>(x, y, z);
}
/** /**
* Construct plane from 3 points * Construct plane from 3 points
@ -118,11 +114,7 @@ namespace Phanes::Core::Math {
* @param(p3) Point three * @param(p3) Point three
*/ */
TPlane(const TVector3<Real>& p1, const TVector3<Real>& p2, const TVector3<Real>& p3) TPlane(const TVector3<Real, S>& p1, const TVector3<Real, S>& p2, const TVector3<Real, S>& p3);
{
this->normal = Normalize(CrossP(p1, p2));
this->d = DotP(this->normal, p3);
}
}; };
@ -141,13 +133,8 @@ namespace Phanes::Core::Math {
* @see [FUNC] PlaneNormalizeV * @see [FUNC] PlaneNormalizeV
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator+= (TPlane<T>& pl1, const TPlane<T>& pl2) TPlane<T, S> operator+= (TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
{
pl1.normal += pl2.normal; pl1.d += pl2.d;
return pl1;
}
/** /**
* Substracts pl2 from pl1. * Substracts pl2 from pl1.
@ -159,13 +146,8 @@ namespace Phanes::Core::Math {
* @see [FUNC] PlaneNormalizeV * @see [FUNC] PlaneNormalizeV
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator-= (TPlane<T>& pl1, const TPlane<T>& pl2) TPlane<T, S> operator-= (TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
{
pl1.normal -= pl2.normal; pl1.d -= pl2.d;
return pl1;
}
/** /**
* Multiplies pl1 with pl2. * Multiplies pl1 with pl2.
@ -177,13 +159,37 @@ namespace Phanes::Core::Math {
* @see [FUNC] PlaneNormalizeV * @see [FUNC] PlaneNormalizeV
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator*= (TPlane<T>& pl1, const TPlane<T>& pl2) TPlane<T, S> operator*= (TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
{
pl1.x *= pl2.x; pl1.y *= pl2.y; pl1.z *= pl2.z; pl1.d *= pl2.d;
return pl1; /// <summary>
} /// Divides pl1 by pl2
/// </summary>
/// <param name="pl1"></param>
/// <param name="pl2"></param>
/// <returns></returns>
template<RealType T, bool S>
TPlane<T, S> operator/= (TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
/// <summary>
/// Add scalar to plane
/// </summary>
/// <param name="pl1"></param>
/// <param name="s"></param>
/// <returns></returns>
template<RealType T, bool S>
TPlane<T, S> operator+= (TPlane<T, S>& pl1, T s);
/// <summary>
/// Substract scalar from plane
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="pl1"></param>
/// <param name="s"></param>
/// <returns></returns>
template<RealType T, bool S>
TPlane<T, S> operator-= (TPlane<T, S>& pl1, T s);
/** /**
* Multiplies pl1 with a scalar * Multiplies pl1 with a scalar
@ -192,13 +198,8 @@ namespace Phanes::Core::Math {
* @param(s) Scalar to multiply with * @param(s) Scalar to multiply with
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator*= (TPlane<T>& pl1, T s) TPlane<T, S> operator*= (TPlane<T, S>& pl1, T s);
{
pl1.normal *= s; pl1 *= s;
return pl1;
}
/** /**
* Divides pl1 with a scalar * Divides pl1 with a scalar
@ -207,15 +208,8 @@ namespace Phanes::Core::Math {
* @param(s) Scalar to divide with * @param(s) Scalar to divide with
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator/= (TPlane<T>& pl1, T s) TPlane<T, S> operator/= (TPlane<T, S>& pl1, T s);
{
T _1_s = (T)1.0 / s;
pl1.normal *= _1_s; pl1 *= _1_s;
return pl1;
}
/** /**
@ -227,11 +221,8 @@ namespace Phanes::Core::Math {
* @return Sum of planes * @return Sum of planes
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator+ (const TPlane<T>& pl1, const TPlane<T>& pl2) TPlane<T, S> operator+ (const TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
{
return TPlane<T>(pl1.normal + pl2.normal, pl1.d + pl2.d);
}
/** /**
* Substracts two planes. * Substracts two planes.
@ -242,11 +233,8 @@ namespace Phanes::Core::Math {
* @return Difference of the planes * @return Difference of the planes
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator- (const TPlane<T>& pl1, const TPlane<T>& pl2) TPlane<T, S> operator- (const TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
{
return TPlane<T>(pl1.normal - pl2.normal, pl1.d - pl2.d);
}
/** /**
* Multiplies two planes. * Multiplies two planes.
@ -257,11 +245,41 @@ namespace Phanes::Core::Math {
* @return Product of planes * @return Product of planes
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator* (const TPlane<T>& pl1, const TPlane<T>& pl2) TPlane<T, S> operator* (const TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
{
return TPlane<T>(pl1.x * pl2.x, pl1.y * pl2.y, pl1.z * pl2.z, pl1.d * pl2.d); /// <summary>
} /// Divides plane by plane
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="pl1"></param>
/// <param name="pl2"></param>
/// <returns></returns>
template<RealType T, bool S>
TPlane<T, S> operator/ (const TPlane<T, S>& pl1, const TPlane<T, S>& pl2);
/// <summary>
/// Add scalar to plane
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="pl1"></param>
/// <param name="s"></param>
/// <returns></returns>
template<RealType T, bool S>
TPlane<T, S> operator+ (const TPlane<T, S>& pl1, T s);
/// <summary>
/// Substracts scalar from plane
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="S"></typeparam>
/// <param name="pl1"></param>
/// <param name="s"></param>
/// <returns></returns>
template<RealType T, bool S>
TPlane<T, S> operator- (const TPlane<T, S>& pl1, T s);
/** /**
* Multiplies pl1 with a scalar * Multiplies pl1 with a scalar
@ -272,11 +290,8 @@ namespace Phanes::Core::Math {
* @return Product of plane and scalar * @return Product of plane and scalar
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator*= (const TPlane<T>& pl1, T s) TPlane<T, S> operator* (const TPlane<T, S>& pl1, T s);
{
return TPlane<T>(pl1.normal * s, pl1.d * s);
}
/** /**
* Divides pl1 with a scalar * Divides pl1 with a scalar
@ -287,13 +302,8 @@ namespace Phanes::Core::Math {
* @return Quotient of plane and scalar * @return Quotient of plane and scalar
*/ */
template<RealType T> template<RealType T, bool S>
TPlane<T> operator/= (const TPlane<T>& pl1, T s) TPlane<T, S> operator/ (const TPlane<T, S>& 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 * Tests two planes for equality
@ -307,9 +317,9 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
bool operator== (const TPlane<T>& pl1, const TPlane<T>& pl2) FORCEINLINE bool operator== (const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{ {
return pl1.normal == pl2.normal && abs(pl1.d - pl2.d) < P_FLT_INAC; return pl1.comp == pl2.comp;
} }
/** /**
@ -324,9 +334,9 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
bool operator!= (const TPlane<T>& pl1, const TPlane<T>& pl2) FORCEINLINE bool operator!= (const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{ {
return pl1.normal != pl2.normal || abs(pl1.d - pl2.d) >= P_FLT_INAC; return pl1.comp != pl2.comp;
} }
@ -335,8 +345,6 @@ namespace Phanes::Core::Math {
// ======================= // // ======================= //
/** /**
* Tests whether two planes are perpendicular. * Tests whether two planes are perpendicular.
* *
@ -348,9 +356,9 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
inline bool IsPerpendicular(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = P_FLT_INAC) inline bool IsPerpendicular(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2, T threshold = P_FLT_INAC)
{ {
return (abs(DotP(pl1.normal, pl2.normal)) < threshold); return (Abs(DotP(pl1.normal, pl2.normal)) < threshold);
} }
/** /**
@ -364,9 +372,9 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
inline bool IsParallel(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = 1.0f - P_FLT_INAC) inline bool IsParallel(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2, T threshold = 1.0f - P_FLT_INAC)
{ {
return (abs(DotP(pl1.normal, pl2.normal)) > threshold); return (Abs(DotP(pl1.normal, pl2.normal)) > threshold);
} }
/** /**
@ -380,7 +388,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
inline bool IsCoincident(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = 1.0f - P_FLT_INAC) inline bool IsCoincident(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2, T threshold = 1.0f - P_FLT_INAC)
{ {
return (DotP(pl1.normal, pl2.normal) > threshold); return (DotP(pl1.normal, pl2.normal) > threshold);
} }
@ -395,7 +403,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
inline bool IsNormalized(const TPlane<T>& pl1, T threshold = P_FLT_INAC) inline bool IsNormalized(const TPlane<T, false>& pl1, T threshold = P_FLT_INAC)
{ {
return (SqrMagnitude(pl1.normal) < threshold); return (SqrMagnitude(pl1.normal) < threshold);
} }
@ -414,7 +422,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
inline bool IsSame(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = P_FLT_INAC) inline bool IsSame(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2, T threshold = P_FLT_INAC)
{ {
return DotP(pl1.normal, pl2.normal) > threshold && abs(pl1.d - pl2.d) < P_FLT_INAC; return DotP(pl1.normal, pl2.normal) > threshold && abs(pl1.d - pl2.d) < P_FLT_INAC;
@ -427,7 +435,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> PlaneNormalizeV(TPlane<T>& pl1) TPlane<T, false> PlaneNormalizeV(TPlane<T, false>& pl1)
{ {
T normVec = SqrMagnitude(pl1); T normVec = SqrMagnitude(pl1);
@ -447,13 +455,13 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> PlaneNormalize(TPlane<T>& pl1) TPlane<T, false> PlaneNormalize(TPlane<T, false>& pl1)
{ {
T normVec = SqrMagnitude(pl1); T normVec = SqrMagnitude(pl1);
T scale = (normVec > P_FLT_INAC) ? (T)1.0 / sqrt(normVec) : 1.0f; T scale = (normVec > P_FLT_INAC) ? (T)1.0 / sqrt(normVec) : 1.0f;
return TPlane<T>(pl1.normal * scale, pl1.d * scale); return TPlane<T, false>(pl1.normal * scale, pl1.d * scale);
} }
/** /**
@ -465,7 +473,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> PlaneUnsafeNormalizeV(TPlane<T>& pl1) TPlane<T, false> PlaneUnsafeNormalizeV(TPlane<T, false>& pl1)
{ {
T scale = (T)1.0 / Magnitude(pl1); T scale = (T)1.0 / Magnitude(pl1);
@ -485,11 +493,11 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> PlaneUnsafeNormalize(TPlane<T>& pl1) TPlane<T, false> PlaneUnsafeNormalize(TPlane<T, false>& pl1)
{ {
T scale = (T)1.0 / Magnitude(pl1); T scale = (T)1.0 / Magnitude(pl1);
return TPlane<T>(pl1.normal * scale, pl1.d * scale); return TPlane<T, false>(pl1.normal * scale, pl1.d * scale);
} }
/** /**
@ -500,7 +508,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE T PlaneDotP(const TPlane<T>& pl1, const TPlane<T>& pl2) FORCEINLINE T PlaneDotP(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{ {
return DotP(pl1.normal, pl2.normal); return DotP(pl1.normal, pl2.normal);
} }
@ -513,7 +521,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE T PlaneAngle(const TPlane<T>& pl1, const TPlane<T>& pl2) FORCEINLINE T PlaneAngle(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{ {
return Angle(pl1.normal, pl2.normal); return Angle(pl1.normal, pl2.normal);
} }
@ -526,7 +534,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE T PlaneCosAngle(const TPlane<T>& pl1, const TPlane<T>& pl2) FORCEINLINE T PlaneCosAngle(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2)
{ {
return CosineAngle(pl1.normal, pl2.normal); return CosineAngle(pl1.normal, pl2.normal);
} }
@ -538,7 +546,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> FlipV(const TPlane<T>& pl1) TPlane<T, false> FlipV(const TPlane<T, false>& pl1)
{ {
pl1.normal = -pl1.normal; pl1.normal = -pl1.normal;
pl1.d = -pl1.d; pl1.d = -pl1.d;
@ -554,9 +562,9 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> Flip(const TPlane<T>& pl1) TPlane<T, false> Flip(const TPlane<T, false>& pl1)
{ {
return TPlane<T>(-pl1.normal, -pl1.d); return TPlane<T, false>(-pl1.normal, -pl1.d);
} }
/** /**
@ -567,7 +575,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TPlane<T> TransformV(TPlane<T>& pl, const TTransform<T>& tr) FORCEINLINE TPlane<T, false> TransformV(TPlane<T, false>& pl, const TTransform<T>& tr)
{ {
// TODO: Do with operator* // TODO: Do with operator*
} }
@ -583,7 +591,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TPlane<T> Transform(const TPlane<T>& pl, const TTransform<T>& tr) FORCEINLINE TPlane<T, false> Transform(const TPlane<T, false>& pl, const TTransform<T>& tr)
{ {
// TODO: Do with operator* // TODO: Do with operator*
} }
@ -599,7 +607,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
T PointDistance(const TPlane<T>& pl1, const TVector3<T>& p1) T PointDistance(const TPlane<T, false>& pl1, const TVector3<T, false>& p1)
{ {
return (pl1.x * p1.x + pl1.y * p1.y + pl1.z * p1.z) - pl1.d; return (pl1.x * p1.x + pl1.y * p1.y + pl1.z * p1.z) - pl1.d;
} }
@ -613,9 +621,9 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TVector3<T> GetOrigin(const TPlane<T>& pl1) TVector3<T, false> GetOrigin(const TPlane<T, false>& pl1)
{ {
return TVector3<T>(pl1.normal * d); return TVector3<T, false>(pl1.normal * pl1.d);
} }
/** /**
@ -626,7 +634,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> TranslateV(TPlane<T>& pl1, const TVector3<T>& v1) TPlane<T, false> TranslateV(TPlane<T, false>& pl1, const TVector3<T, false>& v1)
{ {
pl1.d = DotP(this->normal, GetOrigin(pl1) + v1); pl1.d = DotP(this->normal, GetOrigin(pl1) + v1);
@ -642,9 +650,9 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TPlane<T> Translate(TPlane<T>& pl1, const TVector3<T>& v1) TPlane<T, false> Translate(TPlane<T, false>& pl1, const TVector3<T, false>& v1)
{ {
return TPlane<T>(pl1.normal, GetOrigin(pl1) + v1); return TPlane<T, false>(pl1.normal, GetOrigin(pl1) + v1);
} }
/** /**
@ -657,7 +665,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
bool GetSide(const TPlane<T>& pl1, const TVector3<T>& p1) bool GetSide(const TPlane<T, false>& pl1, const TVector3<T, false>& p1)
{ {
return (pl1.d <= DotP(pl1.normal, p1)); return (pl1.d <= DotP(pl1.normal, p1));
} }
@ -673,7 +681,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ProjectOntoPlaneV(TVector3<T>& v1, const TPlane<T>& plane) FORCEINLINE TVector3<T, false> ProjectOntoPlaneV(TVector3<T, false>& v1, const TPlane<T, false>& plane)
{ {
return RejectV(v1, plane.normal); return RejectV(v1, plane.normal);
} }
@ -690,7 +698,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ProjectOntoPlaneV(TVector3<T>& v1, const TVector3<T>& normal) FORCEINLINE TVector3<T, false> ProjectOntoPlaneV(TVector3<T, false>& v1, const TVector3<T, false>& normal)
{ {
return RejectV(v1, normal); return RejectV(v1, normal);
} }
@ -705,7 +713,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ReflectFromPlaneV(TVector3<T>& v1, const TPlane<T>& plane) FORCEINLINE TVector3<T, false> ReflectFromPlaneV(TVector3<T, false>& v1, const TPlane<T, false>& plane)
{ {
return ReflectV(v1, plane.normal); return ReflectV(v1, plane.normal);
} }
@ -720,7 +728,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ReflectFromPlaneV(TVector3<T>& v1, const TVector3<T>& normal) FORCEINLINE TVector3<T, false> ReflectFromPlaneV(TVector3<T, false>& v1, const TVector3<T, false>& normal)
{ {
return ReflectV(v1, normal); return ReflectV(v1, normal);
} }
@ -736,7 +744,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ReflectFromPlane(const TVector3<T>& v1, const TPlane<T>& plane) FORCEINLINE TVector3<T, false> ReflectFromPlane(const TVector3<T, false>& v1, const TPlane<T, false>& plane)
{ {
return Reflect(v1, plane.normal); return Reflect(v1, plane.normal);
} }
@ -751,7 +759,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ReflectFromPlane(const TVector3<T>& v1, const TVector3<T>& normal) FORCEINLINE TVector3<T, false> ReflectFromPlane(const TVector3<T, false>& v1, const TVector3<T, false>& normal)
{ {
return Reflect(v1, normal); return Reflect(v1, normal);
} }
@ -769,7 +777,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ProjectOntoPlane(const TVector3<T>& v1, const TVector3<T>& normal) FORCEINLINE TVector3<T, false> ProjectOntoPlane(const TVector3<T, false>& v1, const TVector3<T, false>& normal)
{ {
return Reject(v1, normal); return Reject(v1, normal);
} }
@ -788,7 +796,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
FORCEINLINE TVector3<T> ProjectOntoPlane(const TVector3<T>& v1, const TPlane<T>& plane) FORCEINLINE TVector3<T, false> ProjectOntoPlane(const TVector3<T, false>& v1, const TPlane<T, false>& plane)
{ {
return Reject(v1, plane.normal); return Reject(v1, plane.normal);
} }
@ -804,7 +812,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
inline bool Equals(const TPlane<T>& pl1, const TPlane<T>& pl2, T threshold = P_FLT_INAC) inline bool Equals(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2, T threshold = P_FLT_INAC)
{ {
return Equals(pl1.normal, pl2.normal, threshold) && abs(pl1.d - pl2.d) < threshold; return Equals(pl1.normal, pl2.normal, threshold) && abs(pl1.d - pl2.d) < threshold;
} }
@ -818,9 +826,9 @@ namespace Phanes::Core::Math {
* @return True, if p1 on pl1, false if not. * @return True, if p1 on pl1, false if not.
*/ */
template<RealType T> template<RealType T>
FORCEINLINE bool IsPointOnPlane(const TPlane<T>& pl1, const TVector3<T>& p1) FORCEINLINE bool IsPointOnPlane(const TPlane<T, false>& pl1, const TVector3<T, false>& p1)
{ {
return (Equals(DotP(pl1.normal, p1), d)); return (Equals(DotP(pl1.normal, p1), p1.d));
} }
/** /**
@ -835,14 +843,14 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
bool PlanesIntersect2(const TPlane<T>& pl1, const TPlane<T>& pl2, Ref<TLine<T>> interLine, T threshold = P_FLT_INAC) bool PlanesIntersect2(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2, Ref<TLine<T>> interLine, T threshold = P_FLT_INAC)
{ {
TVector3<T> dirLine = CrossP(pl1.normal, pl2.normal); TVector3<T, false> dirLine = CrossP(pl1.normal, pl2.normal);
T det = SqrMagnitude(dirLine); T det = SqrMagnitude(dirLine);
if (abs(det) > P_FLT_INAC) if (abs(det) > P_FLT_INAC)
{ {
interLine = MakeRef<TLine<T>(dirLine, (CrossP(dirLine, pl2.normal) * pl1.d + CrossP(dirLine, pl1.normal) * pl2.d) / det); interLine = MakeRef<TLine<T>>(dirLine, (CrossP(dirLine, pl2.normal) * pl1.d + CrossP(dirLine, pl1.normal) * pl2.d) / det);
NormalizeV(interLine); NormalizeV(interLine);
return true; return true;
} }
@ -863,13 +871,13 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
bool PlanesIntersect3(const TPlane<T>& pl1, const TPlane<T>& pl2, const TPlane<T>& pl3, Ref<TVector3<T>> interPoint, T threshold = P_FLT_INAC) bool PlanesIntersect3(const TPlane<T, false>& pl1, const TPlane<T, false>& pl2, const TPlane<T, false>& pl3, Ref<TVector3<T, false>> interPoint, T threshold = P_FLT_INAC)
{ {
T det = DotP(CrossP(pl1.normal, pl2.normal), pl3.normal); T det = DotP(CrossP(pl1.normal, pl2.normal), pl3.normal);
if (abs(det) > P_FLT_INAC) 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); interPoint = MakeRef<TVector3<T, false>>((CrossP(pl3.normal, pl2.normal) * pl1.d + CrossP(pl1.normal, pl3.normal) * pl2.d) / det);
return true; return true;
} }
@ -886,7 +894,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TVector3<T> PlaneMirrorPoint(const TVector3<T>& p1, const TPlane<T>& pl1) TVector3<T, false> PlaneMirrorPoint(const TVector3<T, false>& p1, const TPlane<T, false>& pl1)
{ {
return p1 - pl1.normal * ((T)2.0 * PointDistance(pl1, p1)); return p1 - pl1.normal * ((T)2.0 * PointDistance(pl1, p1));
} }
@ -901,7 +909,7 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
TVector3<T> PointProjectOntoPlane(const TVector3<T>& p1, const TPlane<T>& pl1) TVector3<T, false> PointProjectOntoPlane(const TVector3<T, false>& p1, const TPlane<T, false>& pl1)
{ {
p1 - PointDistance(pl1, p1) * pl1.normal; p1 - PointDistance(pl1, p1) * pl1.normal;
} }
@ -917,13 +925,13 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
bool LineIntersect(const TPlane<T>& pl1, const TLine<T>& l1, Ref<TVector3<T>> p1) bool LineIntersect(const TPlane<T, false>& pl1, const TLine<T>& l1, Ref<TVector3<T, false>> p1)
{ {
T dotProduct = DotP(l1.normal, pl1.normal); T dotProduct = DotP(l1.normal, pl1.normal);
if (abs(dotProduct) > P_FLT_INAC) if (abs(dotProduct) > P_FLT_INAC)
{ {
p1 = MakeRef<TVector3<T>>(l1.base - l1.normal * (DotP(l1.normal * p1.base) / dotProduct)); p1 = MakeRef<TVector3<T, false>>(l1.base - l1.normal * (DotP(l1.normal * p1.base) / dotProduct));
return true; return true;
} }
@ -941,14 +949,14 @@ namespace Phanes::Core::Math {
*/ */
template<RealType T> template<RealType T>
bool RayIntersect(const TPlane<T>& pl1, const TRay<T>& r1, Ref<TVector3<T>> p1) bool RayIntersect(const TPlane<T, false>& pl1, const TRay<T, false>& r1, Ref<TVector3<T, false>> p1)
{ {
T pr = DotP(pl1.normal, Normalize(r1.direction)); T pr = DotP(pl1.normal, Normalize(r1.direction));
T parameter = DotP((GetOrigin(pl1) - r1.origin), pl1.normal) / pr; T parameter = DotP((GetOrigin(pl1) - r1.origin), pl1.normal) / pr;
if (p1 > P_FLT_INAC && parameter >= 0) if (p1 > P_FLT_INAC && parameter >= 0)
{ {
p1 = MakeRef<TVector3<T>>(PointAt(r1, parameter)); p1 = MakeRef<TVector3<T, false>>(PointAt(r1, parameter));
return true; return true;
} }
@ -957,4 +965,5 @@ namespace Phanes::Core::Math {
} // Phanes::Core::Math } // Phanes::Core::Math
// Include operator impl.
#include "Core/public/Math/Plane.inl"

171
Engine/Source/Runtime/Core/public/Math/Plane.inl Normal file
View File

@ -0,0 +1,171 @@
#pragma once
#include "Core/public/Math/Boilerplate.h"
#include "Core/public/Math/Detail/PlaneDecl.inl"
#include "Core/public/Math/SIMD/SIMDIntrinsics.h"
#include "Core/public/Math/SIMD/PhanesSIMDTypes.h"
namespace Phanes::Core::Math
{
template<RealType T, bool S>
TPlane<T, S>::TPlane(const TPlane<T, S>& plane)
{
Detail::construct_plane<T, S>::map(*this, plane);
}
template<RealType T, bool S>
TPlane<T, S>::TPlane(TPlane<T, S>&& plane)
{
Detail::construct_plane<T, S>::map(*this, plane);
}
template<RealType T, bool S>
TPlane<T, S>::TPlane(const TVector3<T, S>& normal, Real d)
{
Detail::construct_plane<T, S>::map(*this, normal, d);
}
template<RealType T, bool S>
TPlane<T, S>::TPlane(const TVector3<T, S>& normal, const TVector3<T, S>& base)
{
Detail::construct_plane<T, S>::map(*this, normal, base);
}
template<RealType T, bool S>
TPlane<T, S>::TPlane(Real x, Real y, Real z, Real d)
{
Detail::construct_plane<T, S>::map(*this, x, y, z, d);
}
template<RealType T, bool S>
TPlane<T, S>::TPlane(const TVector3<T, S>& p1, const TVector3<T, S>& p2, const TVector3<T, S>& p3)
{
Detail::construct_plane<T, S>::map(*this, p1, p2, p3);
}
template<RealType T, bool S>
TPlane<T, S> operator+=(TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
Detail::compute_plane_add(pl1, pl1, pl2);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator+=(TPlane<T, S>& pl1, T s)
{
Detail::compute_plane_add(pl1, pl1, s);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator+(const TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
TPlane<T, S> r;
Detail::compute_plane_add(r, pl1, pl2);
return r;
}
template<RealType T, bool S>
TPlane<T, S> operator+(const TPlane<T, S>& pl1, T s)
{
TPlane<T, S> r;
Detail::compute_plane_add(r, pl1, s);
return r;
}
template<RealType T, bool S>
TPlane<T, S> operator-=(TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
Detail::compute_plane_sub(pl1, pl1, pl2);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator-=(TPlane<T, S>& pl1, T s)
{
Detail::compute_plane_sub(pl1, pl1, s);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator-(const TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
TPlane<T, S> r;
Detail::compute_plane_sub(r, pl1, pl2);
return r;
}
template<RealType T, bool S>
TPlane<T, S> operator-(const TPlane<T, S>& pl1, T s)
{
TPlane<T, S> r;
Detail::compute_plane_sub(r, pl1, s);
return r;
}
template<RealType T, bool S>
TPlane<T, S> operator*=(TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
Detail::compute_plane_mul(pl1, pl1, pl2);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator*=(TPlane<T, S>& pl1, T s)
{
Detail::compute_plane_mul(pl1, pl1, s);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator*(const TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
TPlane<T, S> r;
Detail::compute_plane_mul(r, pl1, pl2);
return r;
}
template<RealType T, bool S>
TPlane<T, S> operator*(const TPlane<T, S>& pl1, T s)
{
TPlane<T, S> r;
Detail::compute_plane_mul(r, pl1, s);
return r;
}
template<RealType T, bool S>
TPlane<T, S> operator/=(TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
Detail::compute_plane_div(pl1, pl1, pl2);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator/=(TPlane<T, S>& pl1, T s)
{
Detail::compute_plane_div(pl1, pl1, s);
return pl1;
}
template<RealType T, bool S>
TPlane<T, S> operator/(const TPlane<T, S>& pl1, const TPlane<T, S>& pl2)
{
TPlane<T, S> r;
Detail::compute_plane_sub(r, pl1, pl2);
return r;
}
template<RealType T, bool S>
TPlane<T, S> operator/(const TPlane<T, S>& pl1, T s)
{
TPlane<T, S> r;
Detail::compute_plane_sub(r, pl1, s);
return r;
}
}