db/d56/_transform_8h_source.htm

#pragma once


#include <Foundation/Math/Mat3.h>

#include <Foundation/Math/Mat4.h>

#include <Foundation/Math/Quat.h>

#include <Foundation/Math/Vec3.h>


template <typename Type>


class plTransformTemplate

{

public:

  PL_DECLARE_POD_TYPE();


  // *** Data ***

  plVec3Template<Type> m_vPosition;

  plQuatTemplate<Type> m_qRotation;

  plVec3Template<Type> m_vScale;


  // *** Constructors ***

public:

  plTransformTemplate() = default;


  plTransformTemplate(const plVec3Template<Type>& vPosition,

    const plQuatTemplate<Type>& qRotation = plQuatTemplate<Type>::MakeIdentity(),

    const plVec3Template<Type>& vScale = plVec3Template<Type>(1)); // [tested]


  [[nodiscard]] static plTransformTemplate<Type> Make(const plVec3Template<Type>& vPosition, const plQuatTemplate<Type>& qRotation = plQuatTemplate<Type>::MakeIdentity(), const plVec3Template<Type>& vScale = plVec3Template<Type>(1));


  [[nodiscard]] static plTransformTemplate<Type> MakeIdentity();


  [[nodiscard]] static plTransformTemplate<Type> MakeFromMat4(const plMat4Template<Type>& mMat);


  [[nodiscard]] static plTransformTemplate<Type> MakeLocalTransform(const plTransformTemplate& globalTransformParent, const plTransformTemplate& globalTransformChild); // [tested]


  [[nodiscard]] static plTransformTemplate<Type> MakeGlobalTransform(const plTransformTemplate& globalTransformParent, const plTransformTemplate& localTransformChild); // [tested]


  void SetIdentity(); // [tested]


  Type GetMaxScale() const;


  bool HasMirrorScaling() const;


  bool ContainsUniformScale() const;


  bool IsValid() const;


  // *** Equality ***

public:

  bool IsIdentical(const plTransformTemplate& rhs) const; // [tested]


  bool IsEqual(const plTransformTemplate& rhs, Type fEpsilon) const; // [tested]


  // *** Inverse ***

public:

  void Invert(); // [tested]


  const plTransformTemplate GetInverse() const;                                               // [tested]


  [[nodiscard]] plVec3Template<Type> TransformPosition(const plVec3Template<Type>& v) const;  // [tested]

  [[nodiscard]] plVec3Template<Type> TransformDirection(const plVec3Template<Type>& v) const; // [tested]


  void operator+=(const plVec3Template<Type>& v);                                             // [tested]

  void operator-=(const plVec3Template<Type>& v);                                             // [tested]


  // *** Conversion operations ***

public:

  const plMat4Template<Type> GetAsMat4() const; // [tested]

};


// *** free functions ***


template <typename Type>

const plVec3Template<Type> operator*(const plTransformTemplate<Type>& t, const plVec3Template<Type>& v); // [tested]


template <typename Type>

const plTransformTemplate<Type> operator*(const plQuatTemplate<Type>& q, const plTransformTemplate<Type>& t); // [tested]


template <typename Type>

const plTransformTemplate<Type> operator*(const plTransformTemplate<Type>& t, const plQuatTemplate<Type>& q);


template <typename Type>

const plTransformTemplate<Type> operator+(const plTransformTemplate<Type>& t, const plVec3Template<Type>& v); // [tested]


template <typename Type>

const plTransformTemplate<Type> operator-(const plTransformTemplate<Type>& t, const plVec3Template<Type>& v); // [tested]


template <typename Type>

const plTransformTemplate<Type> operator*(const plTransformTemplate<Type>& t1, const plTransformTemplate<Type>& t2); // [tested]


template <typename Type>

bool operator==(const plTransformTemplate<Type>& t1, const plTransformTemplate<Type>& t2);                           // [tested]


template <typename Type>

bool operator!=(const plTransformTemplate<Type>& t1, const plTransformTemplate<Type>& t2);                           // [tested]


#include <Foundation/Math/Implementation/Transform_inl.h>

plMat4Template
A 4x4 component matrix class.
Definition Mat4.h:11

plQuatTemplate
Quaternions can be used to represent rotations in 3D space.
Definition Quat.h:19

plTransformTemplate
A class that represents position, rotation and scaling via a position vector, a quaternion and a scal...
Definition Transform.h:31

plTransformTemplate::Invert
void Invert()
Inverts this transform.
Definition Transform_inl.h:230

plTransformTemplate::MakeIdentity
static plTransformTemplate< Type > MakeIdentity()
Creates an identity transform.
Definition Transform_inl.h:25

plTransformTemplate::MakeGlobalTransform
static plTransformTemplate< Type > MakeGlobalTransform(const plTransformTemplate &globalTransformParent, const plTransformTemplate &localTransformChild)
Creates a transform that is the global transform, that is reached by applying the child's local trans...
Definition Transform_inl.h:61

plTransformTemplate::MakeLocalTransform
static plTransformTemplate< Type > MakeLocalTransform(const plTransformTemplate &globalTransformParent, const plTransformTemplate &globalTransformChild)
Creates a transform that is the local transformation needed to get from the parent's transform to the...
Definition Transform_inl.h:48

plTransformTemplate::HasMirrorScaling
bool HasMirrorScaling() const
Returns whether this transform contains negative scaling aka mirroring.
Definition Transform_inl.h:80

plTransformTemplate::GetAsMat4
const plMat4Template< Type > GetAsMat4() const
Returns the transformation as a matrix.
Definition Transform_inl.h:111

plTransformTemplate::IsValid
bool IsValid() const
Checks that all components are valid (no NaN, only finite numbers).
Definition Transform_inl.h:105

plTransformTemplate::GetInverse
const plTransformTemplate GetInverse() const
Returns the inverse of this transform.
Definition Transform_inl.h:236

plTransformTemplate::IsEqual
bool IsEqual(const plTransformTemplate &rhs, Type fEpsilon) const
Equality Check with epsilon.
Definition Transform_inl.h:99

plTransformTemplate::GetMaxScale
Type GetMaxScale() const
Returns the scale component with maximum magnitude.
Definition Transform_inl.h:73

plTransformTemplate::SetIdentity
void SetIdentity()
Sets the position to be zero and the rotation to identity.
Definition Transform_inl.h:67

plTransformTemplate::IsIdentical
bool IsIdentical(const plTransformTemplate &rhs) const
Equality Check (bitwise)
Definition Transform_inl.h:93

plTransformTemplate::ContainsUniformScale
bool ContainsUniformScale() const
Returns whether this transform contains uniform scaling.
Definition Transform_inl.h:86

plTransformTemplate::plTransformTemplate
plTransformTemplate()=default
Default constructor: Does not do any initialization.

plTransformTemplate::Make
static plTransformTemplate< Type > Make(const plVec3Template< Type > &vPosition, const plQuatTemplate< Type > &qRotation=plQuatTemplate< Type >::MakeIdentity(), const plVec3Template< Type > &vScale=plVec3Template< Type >(1))
Creates a transform from the given position, rotation and scale.
Definition Transform_inl.h:15

plTransformTemplate::MakeFromMat4
static plTransformTemplate< Type > MakeFromMat4(const plMat4Template< Type > &mMat)
Creates a transform from the given matrix.
Definition Transform_inl.h:35

plVec3Template
A 3-component vector class.
Definition Vec3.h:9