SystemEx.Numeric.DQuatf Struct Reference

Dual quaternion using single-precision floating point values. Represents a rigid 3D transformation consisting of rotation (real part) and translation (dual part). Provides stable, non-drifting transformations compared to matrix-based approaches. More...

Inheritance diagram for SystemEx.Numeric.DQuatf:

Collaboration diagram for SystemEx.Numeric.DQuatf:

Public Member Functions
	DQuatf (Quatf rotation)
	Creates a dual quaternion with rotation only. Translation is initialized to zero.
	DQuatf (Quatf rotation, Vec3f translation)
	Creates a dual quaternion from rotation and translation.
void	Normalize ()
	Normalizes both rotation and dual components. Required for stable interpolation and accumulation.
void	Rotation (Quatf rotation)
	Sets the rotation component of the dual quaternion.
void	Translation (Vec3f translation)
	Sets the translation component of the dual quaternion. Translation is encoded into the dual part using: qd = 0.5 * (translation_quat * rotation).
void	RotationTranslation (Quatf rotation, Vec3f translation)
	Sets both rotation and translation components. Translation is encoded into the dual part.
DQuatf	Invert ()
	Computes the inverse of the dual quaternion. Inverts rotation and adjusts translation accordingly.
Vec3f	Transform (Vec3f v)
	Transforms a vector using the dual quaternion. Applies rotation and translation without matrix drift.

Static Public Member Functions
static DQuatf	Slerp (DQuatf a, DQuatf b, float t)
	Performs screw-motion interpolation between two dual quaternions. Interpolates rotation and translation simultaneously.
static DQuatf	operator* (DQuatf a, DQuatf b)
	Multiplies two dual quaternions, combining their transformations.
static DQuatf	operator+ (DQuatf a, DQuatf b)
	Linear addition of dual quaternions. Not a valid rigid transformation; used for blending only.
static DQuatf	operator- (DQuatf a, DQuatf b)
	Linear subtraction of dual quaternions. Not a valid rigid transformation; used for blending only.
static DQuatf	operator/ (DQuatf a, float s)
	Divides both components by a scalar. Useful for normalization and weighted blending.
static DQuatf	FromRotationTranslation (Quatf rotation, Vec3f translation)
	Creates a dual quaternion from rotation and translation. Translation is encoded into the dual part using: qd = 0.5 * (translation_quat * rotation).
static DQuatf	FromRotationTranslationConjugated (Quatf rotation, Vec3f translation)
	Creates a dual quaternion using the conjugated rotation. Useful for inverse transformation chains.

Public Attributes
Quatf	m_rot
	Rotation component (real part).
Quatf	m_translation
	Translation component (dual part).

Properties
Quatf	Real [get]
	Gets the rotation component of the dual quaternion.
Quatf	Dual [get]
	Gets the translation component of the dual quaternion.

Detailed Description

Dual quaternion using single-precision floating point values. Represents a rigid 3D transformation consisting of rotation (real part) and translation (dual part). Provides stable, non-drifting transformations compared to matrix-based approaches.

Constructor & Destructor Documentation

DQuatf() [1/2]

SystemEx.Numeric.DQuatf.DQuatf

(

Quatf

rotation

)

Creates a dual quaternion with rotation only. Translation is initialized to zero.

                                         {
            m_rot = rotation;
            m_translation = new Quatf(0f, 0f, 0f, 0f);
        }

Here is the caller graph for this function:

DQuatf() [2/2]

SystemEx.Numeric.DQuatf.DQuatf	(	Quatf	rotation,
		Vec3f	translation )

Creates a dual quaternion from rotation and translation.

                                                            {
            var x = FromRotationTranslation(rotation, translation);
            m_rot = x.m_rot;
            m_translation = x.m_translation;
        }

Here is the call graph for this function:

Member Function Documentation

FromRotationTranslation()

DQuatf SystemEx.Numeric.DQuatf.FromRotationTranslation ( Quatf rotation, Vec3f translation )

static

Creates a dual quaternion from rotation and translation. Translation is encoded into the dual part using: qd = 0.5 * (translation_quat * rotation).

                                                                                           {
            Quatf real = rotation;
            Quatf t = new Quatf(0f, translation.X, translation.Y, translation.Z);
            Quatf dual = 0.5f * (t * rotation);
 
            return new DQuatf
            {
                m_rot = real,
                m_translation = dual
            };
        }

Here is the call graph for this function:

Here is the caller graph for this function:

FromRotationTranslationConjugated()

DQuatf SystemEx.Numeric.DQuatf.FromRotationTranslationConjugated ( Quatf rotation, Vec3f translation )

static

Creates a dual quaternion using the conjugated rotation. Useful for inverse transformation chains.

                                                                                                     {
            Quatf r = Quatf.Conjugate(rotation);
            Quatf t = new Quatf(0f, translation.X, translation.Y, translation.Z);
            Quatf dual = 0.5f * (t * r);
 
            return new DQuatf
            {
                m_rot = r,
                m_translation = dual
            };
        }

Here is the call graph for this function:

Invert()

DQuatf SystemEx.Numeric.DQuatf.Invert

(

)

Computes the inverse of the dual quaternion. Inverts rotation and adjusts translation accordingly.

                                {
            Quatf rInv = Quatf.Invert(m_rot);
            Quatf dInv = -(rInv * m_translation * rInv);
 
            return new DQuatf
            {
                m_rot = rInv,
                m_translation = dInv
            };
        }

Here is the call graph for this function:

Normalize()

void SystemEx.Numeric.DQuatf.Normalize

(

)

Normalizes both rotation and dual components. Required for stable interpolation and accumulation.

                                 {
            float len = Quatf.Lenght(m_rot);
            m_rot /= len;
            m_translation /= len;
        }

Here is the call graph for this function:

operator*()

DQuatf SystemEx.Numeric.DQuatf.operator* ( DQuatf a, DQuatf b )

static

Multiplies two dual quaternions, combining their transformations.

                                                               {
            Quatf real = a.m_rot * b.m_rot;
            Quatf dual = a.m_rot * b.m_translation + a.m_translation * b.m_rot;
 
            DQuatf result;
            result.m_rot = real;
            result.m_translation = dual;
            return result;
        }

Here is the call graph for this function:

operator+()

DQuatf SystemEx.Numeric.DQuatf.operator+ ( DQuatf a, DQuatf b )

static

Linear addition of dual quaternions. Not a valid rigid transformation; used for blending only.

                                                               {
            return new DQuatf
            {
                m_rot = a.m_rot + b.m_rot,
                m_translation = a.m_translation + b.m_translation
            };
        }

Here is the call graph for this function:

operator-()

DQuatf SystemEx.Numeric.DQuatf.operator- ( DQuatf a, DQuatf b )

static

Linear subtraction of dual quaternions. Not a valid rigid transformation; used for blending only.

                                                               {
            return new DQuatf
            {
                m_rot = a.m_rot - b.m_rot,
                m_translation = a.m_translation - b.m_translation
            };
        }

Here is the call graph for this function:

operator/()

DQuatf SystemEx.Numeric.DQuatf.operator/ ( DQuatf a, float s )

static

Divides both components by a scalar. Useful for normalization and weighted blending.

                                                              {
            return new DQuatf
            {
                m_rot = a.m_rot / s,
                m_translation = a.m_translation / s
            };
        }

Here is the call graph for this function:

Rotation()

void SystemEx.Numeric.DQuatf.Rotation

(

Quatf

rotation

)

Sets the rotation component of the dual quaternion.

                                                {
            m_rot = rotation;
        }

RotationTranslation()

void SystemEx.Numeric.DQuatf.RotationTranslation	(	Quatf	rotation,
		Vec3f	translation )

Sets both rotation and translation components. Translation is encoded into the dual part.

                                                                              {
            m_rot = rotation;
            Quatf t = new Quatf(0f, translation.X, translation.Y, translation.Z);
            m_translation = 0.5f * (t * rotation);
        }

Slerp()

DQuatf SystemEx.Numeric.DQuatf.Slerp ( DQuatf a, DQuatf b, float t )

static

Performs screw-motion interpolation between two dual quaternions. Interpolates rotation and translation simultaneously.

                                                                   {
            Quatf rot = Quatf.Slerp(a.m_rot, b.m_rot, t);
            Quatf dual = Quatf.Slerp(a.m_translation, b.m_translation, t);
 
            return new DQuatf
            {
                m_rot = rot,
                m_translation = dual
            };
        }

Here is the call graph for this function:

Transform()

Vec3f SystemEx.Numeric.DQuatf.Transform

(

Vec3f

v

)

Transforms a vector using the dual quaternion. Applies rotation and translation without matrix drift.

                                           {
            Quatf p = new Quatf(0f, v.X, v.Y, v.Z);
            Quatf rInv = Quatf.Invert(m_rot);
            Quatf rotated = m_rot * p * rInv;
 
            Quatf trans = m_translation * rInv;
            Vec3f t = new Vec3f(trans.X, trans.Y, trans.Z) * 2f;
 
            return new Vec3f(rotated.X, rotated.Y, rotated.Z) + t;
        }

Here is the call graph for this function:

Translation()

void SystemEx.Numeric.DQuatf.Translation

(

Vec3f

translation

)

Sets the translation component of the dual quaternion. Translation is encoded into the dual part using: qd = 0.5 * (translation_quat * rotation).

                                                      {
            Quatf t = new Quatf(0f, translation.X, translation.Y, translation.Z);
            m_translation = 0.5f * (t * m_rot);
        }

Member Data Documentation

m_rot

Quatf SystemEx.Numeric.DQuatf.m_rot

Rotation component (real part).

m_translation

Quatf SystemEx.Numeric.DQuatf.m_translation

Translation component (dual part).

Property Documentation

Dual

Quatf SystemEx.Numeric.DQuatf.Dual

get

Gets the translation component of the dual quaternion.

Real

Quatf SystemEx.Numeric.DQuatf.Real

get

Gets the rotation component of the dual quaternion.

---

The documentation for this struct was generated from the following file:

• DQuadv.cs