Declarations.h

#pragma once
 
 
#include <Foundation/Basics.h>
 
#if PL_ENABLED(PL_MATH_CHECK_FOR_NAN)
#  define PL_NAN_ASSERT(obj) (obj)->AssertNotNaN();
#else
#  define PL_NAN_ASSERT(obj)
#endif
 
#define PL_DECLARE_IF_FLOAT_TYPE template <typename = typename std::enable_if<std::is_floating_point_v<Type> == true>>
#define PL_IMPLEMENT_IF_FLOAT_TYPE template <typename ENABLE_IF_FLOAT>
 
union plIntFloatUnion
{
  constexpr plIntFloatUnion(float fInit)
    : f(fInit)
  {
  }
 
  constexpr plIntFloatUnion(plUInt32 uiInit)
    : i(uiInit)
  {
  }
 
  plUInt32 i;
  float f;
};
 
union plInt64DoubleUnion
{
 
  constexpr plInt64DoubleUnion(double fInit)
    : f(fInit)
  {
  }
  constexpr plInt64DoubleUnion(plUInt64 uiInit)
    : i(uiInit)
  {
  }
 
  plUInt64 i;
  double f;
};
 
struct plMatrixLayout
{
  enum Enum
  {
    RowMajor,   
    ColumnMajor 
  };
};
 
struct plClipSpaceDepthRange
{
  enum Enum
  {
    MinusOneToOne, 
    ZeroToOne,     
  };
 
  PL_FOUNDATION_DLL static Enum Default;
};
 
struct plClipSpaceYMode
{
  enum Enum
  {
    Regular, 
    Flipped, 
  };
 
  PL_FOUNDATION_DLL static Enum RenderToTextureDefault;
};
 
struct plHandedness
{
  enum Enum
  {
    LeftHanded,
    RightHanded,
  };
 
  PL_FOUNDATION_DLL static Enum Default /*= plHandedness::LeftHanded*/;
};
 
// forward declarations
template <typename Type>
class plVec2Template;
 
using plVec2 = plVec2Template<float>;
using plVec2d = plVec2Template<double>;
using plVec2I32 = plVec2Template<plInt32>;
using plVec2U32 = plVec2Template<plUInt32>;
using plVec2I64 = plVec2Template<plInt64>;
using plVec2U64 = plVec2Template<plUInt64>;
 
template <typename Type>
class plVec3Template;
 
using plVec3 = plVec3Template<float>;
using plVec3d = plVec3Template<double>;
using plVec3I32 = plVec3Template<plInt32>;
using plVec3U32 = plVec3Template<plUInt32>;
using plVec3I64 = plVec3Template<plInt64>;
using plVec3U64 = plVec3Template<plUInt64>;
 
template <typename Type>
class plVec4Template;
 
using plVec4 = plVec4Template<float>;
using plVec4d = plVec4Template<double>;
using plVec4I64 = plVec4Template<plInt64>;
using plVec4I32 = plVec4Template<plInt32>;
using plVec4I16 = plVec4Template<plInt16>;
using plVec4I8 = plVec4Template<plInt8>;
using plVec4U64 = plVec4Template<plUInt64>;
using plVec4U32 = plVec4Template<plUInt32>;
using plVec4U16 = plVec4Template<plUInt16>;
using plVec4U8 = plVec4Template<plUInt8>;
 
template <typename Type>
class plMat3Template;
 
using plMat3 = plMat3Template<float>;
using plMat3d = plMat3Template<double>;
 
template <typename Type>
class plMat4Template;
 
using plMat4 = plMat4Template<float>;
using plMat4d = plMat4Template<double>;
 
template <typename Type>
struct plPlaneTemplate;
 
using plPlane = plPlaneTemplate<float>;
using plPlaned = plPlaneTemplate<double>;
 
template <typename Type>
class plQuatTemplate;
 
using plQuat = plQuatTemplate<float>;
using plQuatd = plQuatTemplate<double>;
 
template <typename Type>
class plBoundingBoxTemplate;
 
using plBoundingBox = plBoundingBoxTemplate<float>;
using plBoundingBoxd = plBoundingBoxTemplate<double>;
using plBoundingBoxu32 = plBoundingBoxTemplate<plUInt32>;
 
template <typename Type>
class plBoundingBoxSphereTemplate;
 
using plBoundingBoxSphere = plBoundingBoxSphereTemplate<float>;
using plBoundingBoxSphered = plBoundingBoxSphereTemplate<double>;
 
template <typename Type>
class plBoundingSphereTemplate;
 
using plBoundingSphere = plBoundingSphereTemplate<float>;
using plBoundingSphered = plBoundingSphereTemplate<double>;
 
template <plUInt8 DecimalBits>
class plFixedPoint;
 
class plAngle;
 
template <typename Type>
class plTransformTemplate;
 
using plTransform = plTransformTemplate<float>;
using plTransformd = plTransformTemplate<double>;
 
class plColor;
class plColorLinearUB;
class plColorGammaUB;
 
class plRandom;
 
template <typename Type>
class plRectTemplate;
 
using plRectU32 = plRectTemplate<plUInt32>;
using plRectU16 = plRectTemplate<plUInt16>;
using plRectI32 = plRectTemplate<plInt32>;
using plRectI16 = plRectTemplate<plInt16>;
using plRectFloat = plRectTemplate<float>;
using plRectDouble = plRectTemplate<double>;
 
class plFrustum;
 
 
struct PL_FOUNDATION_DLL plBasisAxis
{
  using StorageType = plInt8;
 
  enum Enum : plInt8
  {
    PositiveX,
    PositiveY,
    PositiveZ,
    NegativeX,
    NegativeY,
    NegativeZ,
 
    Default = PositiveX
  };
 
  static plVec3 GetBasisVector(plBasisAxis::Enum basisAxis);
 
  static plMat3 CalculateTransformationMatrix(plBasisAxis::Enum forwardDir, plBasisAxis::Enum rightDir, plBasisAxis::Enum dir, float fUniformScale = 1.0f, float fScaleX = 1.0f, float fScaleY = 1.0f, float fScaleZ = 1.0f);
 
  static plQuat GetBasisRotation(plBasisAxis::Enum identity, plBasisAxis::Enum axis);
 
  static plQuat GetBasisRotation_PosX(plBasisAxis::Enum axis);
 
  static plBasisAxis::Enum GetOrthogonalAxis(plBasisAxis::Enum axis1, plBasisAxis::Enum axis2, bool bFlip);
};
 
struct PL_FOUNDATION_DLL plComparisonOperator
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    Equal,
    NotEqual,
    Less,
    LessEqual,
    Greater,
    GreaterEqual,
 
    Default = Equal
  };
 
  template <typename T>
  static bool Compare(plComparisonOperator::Enum cmp, const T& a, const T& b); // [tested]
};