SystemEx.Numeric.Quatf Struct Reference

Represents a floating‑point quaternion used for 3D rotations. More...

Inheritance diagram for SystemEx.Numeric.Quatf:

Collaboration diagram for SystemEx.Numeric.Quatf:

Public Member Functions
	Quatf ()
	Initializes the identity quaternion (1,0,0,0).
float	Get (int index)
	Gets a component by index .
	Quatf (Vec3f angles)
	Initializes a quaternion from Euler angles (XYZ order).
	Quatf (float fs, float fx, float fy, float fz)
	Initializes a quaternion from explicit components.
	Quatf (float[] pfs)
	Initializes a quaternion from a float array.
	Quatf (AxisAngle< Vec3f, float > axisAngle)
	Initializes a quaternion from an axis‑angle representation.
	Quatf (Quatf other)
	Copy constructor.
Vec3f	GetRotationAxis ()
	Computes the normalized rotation axis of this quaternion.
float	GetRotationAngle ()
	Returns the rotation angle represented by this quaternion.
CompareResult	CompareTo (Quatf a)
	Compares two quaternions using the configured CompareMode.
int IComparable< Quatf >.	CompareTo (Quatf other)
int	CompareTo (object? obj)
	Compares this quaternion to another object.
bool	Equals (Quatf other)
FixedVector< byte >	ToBytes ()
	Converts the vector into a deterministic byte sequence.
override int	GetHashCode ()
	Computes a hash code for this vector.
override bool	Equals (object? obj)
	Determines whether this instance is equal to another object.
Public Member Functions inherited from SystemEx.IComparableEx< T >
CompareResult	CompareTo (T a)
	Compares this instance with the specified value and returns a CompareResult describing the relationship between them.

Static Public Member Functions
static AxisAngle< Vec3f, float >	ToAxisAngle (Quatf q)
	Converts a quaternion into an axis‑angle representation.
static Quatf	FromAxis (AxisAngle< Vec3f, float > axisAngle)
	Creates a quaternion from an axis‑angle representation.
static bool	IsIdentity (Quatf v)
	Determines whether a quaternion is the identity rotation.
static Quatf	Exponent (Quatf v)
	Computes the quaternion exponential.
static Quatf	Logarithm (Quatf v)
	Computes the quaternion logarithm.
static float	LenghtSqrt (Quatf v)
	Computes the Euclidean length of the quaternion.
static float	Lenght (Quatf v)
	Computes the squared length of the quaternion.
static Quatf	Power (Quatf v, float Exp)
	Raises a quaternion to a scalar power.
static float	DotProduct (Quatf a, Quatf b)
	Computes the DotProduct product of two quaternions.
static Quatf	Invert (Quatf q)
	Computes the inverse of a quaternion.
static Quatf	Normalize (Quatf v)
	Normalizes a quaternion to unit length.
static Quatf	Conjugate (Quatf v)
	Computes the quaternion conjugate.
static Quatf	Slerp (Quatf q0, Quatf q1, float t)
	Performs spherical linear interpolation between two quaternions.
static Quatf	operator* (Quatf a, Quatf b)
	Multiplies two Quatf component‑wise.
static Quatf	operator* (float a, Quatf b)
	Multiplicate a float with a quaternion.
static Quatf	operator* (Quatf a, float b)
	Multiplicate a quaternion with a float.
static Quatf	operator+ (Quatf a, Quatf b)
	Adds two Quatf component‑wise.
static Quatf	operator- (Quatf a, Quatf b)
	Subtracts two Quatf component‑wise.
static Quatf	operator- (Quatf a)
	Invert.
static Quatf	operator/ (Quatf a, Quatf b)
	Divides two Quatf component‑wise.
static Quatf	operator/ (Quatf a, float b)
	Divides both components of the Quatf by a float.

Properties
float	S [get, set]
	Gets or sets the scalar component (w) of the quaternion.
Vec3f	V [get, set]
	Gets or sets the vector component (x,y,z) of the quaternion.
float	X [get, set]
	Gets or sets the X component of the quaternion's vector part.
float	Y [get, set]
	Gets or sets the Y component of the quaternion's vector part.
float	Z [get, set]
	Gets or sets the Z component of the quaternion's vector part.
AxisAngle< Vec3f, float >	AxisAngle [get]
	Gets the axis‑angle representation of this quaternion.
CompareType	CompareMode [get, set]
	Gets or sets the comparison mode used by CompareTo(Quatf).

Detailed Description

Represents a floating‑point quaternion used for 3D rotations.

Quatf stores a scalar component w and a vector component (x,y,z) in a sequential memory layout, making it suitable for native interop, compute kernels, and deterministic hashing.

The struct is annotated with HashAlgorithmAttribute to enable attribute‑driven hashing via HashFactory.
BernsteinHash is used because it is fast, byte‑linear, and ideal for small fixed‑size numeric types.

Quatf implements multiple comparison and hashing interfaces:

• IComparable and IComparable<T> for ordering
• IEquatable<T> for equality checks
• IHashable<T> for deterministic byte‑level hashing

Constructor & Destructor Documentation

Quatf() [1/6]

SystemEx.Numeric.Quatf.Quatf

(

)

Initializes the identity quaternion (1,0,0,0).

                        {
            m_v = new Vec3f(0);
            m_s = 1.0f;
            m_comparebleMode = CompareType.Skalar;
        }

Here is the caller graph for this function:

Quatf() [2/6]

SystemEx.Numeric.Quatf.Quatf

(

Vec3f

angles

)

Initializes a quaternion from Euler angles (XYZ order).

                                      {
            float cos_z_2 = System.MathF.Cos(0.5f*angles.Z);
            float cos_y_2 = System.MathF.Cos(0.5f*angles.Y);
            float cos_x_2 = System.MathF.Cos(0.5f*angles.X);
 
            float sin_z_2 = System.MathF.Sin(0.5f*angles.Z);
            float sin_y_2 = System.MathF.Sin(0.5f*angles.Y);
            float sin_x_2 = System.MathF.Sin(0.5f*angles.X);
 
            // and now compute quaternion
            m_s = cos_z_2 * cos_y_2 * cos_x_2 + sin_z_2 * sin_y_2 * sin_x_2;
            m_v = new Vec3f
            (
                cos_z_2 * cos_y_2 * sin_x_2 - sin_z_2 * sin_y_2 * cos_x_2,
                cos_z_2 * sin_y_2 * cos_x_2 + sin_z_2 * cos_y_2 * sin_x_2,
                sin_z_2 * cos_y_2 * cos_x_2 - cos_z_2 * sin_y_2 * sin_x_2
            );
            m_comparebleMode = CompareType.Skalar;
        }

Quatf() [3/6]

SystemEx.Numeric.Quatf.Quatf	(	float	fs,
		float	fx,
		float	fy,
		float	fz )

Initializes a quaternion from explicit components.

                                                                {
            m_s = fs;
            m_v = new Vec3f(fx, fy, fz);
            m_comparebleMode = CompareType.Skalar;
        }

Quatf() [4/6]

SystemEx.Numeric.Quatf.Quatf

(

float[]

pfs

)

Initializes a quaternion from a float array.

                                     {
            m_s = pfs[0];
            m_v = new Vec3f(pfs[1], pfs[2], pfs[3]);
            m_comparebleMode = CompareType.Skalar;
        }

Quatf() [5/6]

SystemEx.Numeric.Quatf.Quatf

(

AxisAngle< Vec3f, float >

axisAngle

)

Initializes a quaternion from an axis‑angle representation.

                                                           {
            var tmp = FromAxis(axisAngle);
            m_s = tmp.m_s;
            m_v = tmp.m_v;
            m_comparebleMode = CompareType.Skalar;
        }

Here is the call graph for this function:

Quatf() [6/6]

SystemEx.Numeric.Quatf.Quatf

(

Quatf

other

)

Copy constructor.

                                   {
            m_s = other.m_s;
            m_v = other.m_v;
            m_comparebleMode = CompareType.Skalar;
        }

Here is the call graph for this function:

Member Function Documentation

CompareTo() [1/3]

int SystemEx.Numeric.Quatf.CompareTo

(

object?

obj

)

Compares this quaternion to another object.

                                             {
            if ( (obj is Quatf) ) {
                return (int)CompareTo((Quatf)(obj));
            }
            throw new ArgumentException("Object is not a Quatf object");
        }

Here is the call graph for this function:

CompareTo() [2/3]

CompareResult SystemEx.Numeric.Quatf.CompareTo

(

Quatf

a

)

Compares two quaternions using the configured CompareMode.

                                                   {
 
            CompareResult _ret = CompareResult.Equal;
 
            float _a = 0;
            float _b = 0;
 
            switch ( m_comparebleMode) {
            case CompareType.Skalar:
                _ret = (CompareResult)m_s.CompareTo(a.m_s);
                break;
            case CompareType.Norm:
                _a = m_s * m_s + Vec3f.Lenght(m_v);
                _b = a.m_s * a.m_s + Vec3f.Lenght(a.m_v);
                _ret = (CompareResult)_a.CompareTo(_b);
                break;
            case CompareType.Rotation:
                _a = GetRotationAngle(); 
                _b = a.GetRotationAngle();
                _ret = (CompareResult)_a.CompareTo(_b);
                break;
            }
            return _ret;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

CompareTo() [3/3]

int IComparable< Quatf >. SystemEx.Numeric.Quatf.CompareTo

(

Quatf

other

)

                                                         {
            return (int)CompareTo(other);
        }

Conjugate()

Quatf SystemEx.Numeric.Quatf.Conjugate ( Quatf v )

static

Computes the quaternion conjugate.

                                                  {
            Quatf temp = new Quatf( v);
 
            temp.m_v.X = -temp.m_v.X;
            temp.m_v.Y = -temp.m_v.Y;
            temp.m_v.Z = -temp.m_v.Z;
 
            return temp;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

DotProduct()

float SystemEx.Numeric.Quatf.DotProduct ( Quatf a, Quatf b )

static

Computes the DotProduct product of two quaternions.

                                                            {
            return a.m_s * b.m_s +
                   a.m_v.X * b.m_v.X +
                   a.m_v.Y * b.m_v.Y +
                   a.m_v.Z * b.m_v.Z;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Equals() [1/2]

override bool SystemEx.Numeric.Quatf.Equals

(

object?

obj

)

Determines whether this instance is equal to another object.

The object is considered equal if it is a Quatf and compares equal using Equals(Quatf).

Parameters

obj	The object to compare with.

Returns

true if obj is a Quatf and equal to this instance; otherwise false.

                                                    {
            if ( obj == null ) return false;
            return (obj is Quatf) && Equals((Quatf)obj);
        }

Here is the call graph for this function:

Equals() [2/2]

bool SystemEx.Numeric.Quatf.Equals

(

Quatf

other

)

                                           {
            return m_s == other.m_s && m_v == other.m_v;
        }

Exponent()

Quatf SystemEx.Numeric.Quatf.Exponent ( Quatf v )

static

Computes the quaternion exponential.

                                                 {
            float Mul;
 
            Quatf temp = new Quatf( v);
            float Length = Vec3f.LenghtSqrt(temp.m_v);
 
            if ( Length > 1.0e-4f )
                Mul = System.MathF.Sin(Length) / Length;
            else
                Mul = 1.0f;
 
            temp.m_s = System.MathF.Cos(Length);
 
            temp.m_v.X *= Mul;
            temp.m_v.Y *= Mul;
            temp.m_v.Z *= Mul;
 
            return temp;
        }

Here is the call graph for this function:

FromAxis()

Quatf SystemEx.Numeric.Quatf.FromAxis ( AxisAngle< Vec3f, float > axisAngle )

static

Creates a quaternion from an axis‑angle representation.

                                                                           {
 
            float len = Vec3f.LenghtSqrt(axisAngle.Axis);
            Quatf temp = new Quatf();
 
            if ( len > 1e-12f ) {
                float inv = 1.0f / len;
 
                // Achse normalisieren
                float nx = axisAngle.Axis.X * inv;
                float ny = axisAngle.Axis.Y * inv;
                float nz = axisAngle.Axis.Z * inv;
 
                float omega = 0.5f * axisAngle.Angle;
                float s = MathF.Sin(omega);
 
                temp.m_v = new Vec3f(s * nx, s * ny, s * nz);
                temp.m_s = MathF.Cos(omega);
            } else {
                // Ungültige Achse → Identity
                temp.m_s = 1.0f;
                temp.m_v = Vec3f.Zero;
            }
 
            return Normalize(temp);
 
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Get()

float SystemEx.Numeric.Quatf.Get

(

int

index

)

Gets a component by index .

                                       {
            return index switch
            {
                0 => S,
                1 => X,
                2 => Y,
                3 => Z,
                _ => throw new ArgumentOutOfRangeException(nameof(index))
            };
        }

Here is the caller graph for this function:

GetHashCode()

override int SystemEx.Numeric.Quatf.GetHashCode

(

)

Computes a hash code for this vector.

The primary hash is generated using HashFactory and the HashAlgorithmAttribute applied to this struct.
If hashing fails (rare), a fallback XOR‑based hash is used.

                                           {
            var x =  HashFactory.Hash32(this, 674545);
            if ( x.Value != 0 ) return (int)x.Value;
 
            return m_v.GetHashCode() ^ m_s.GetHashCode() ;
 
        }

GetRotationAngle()

float SystemEx.Numeric.Quatf.GetRotationAngle

(

)

Returns the rotation angle represented by this quaternion.

                                        {
            float s = System.Math.Clamp(m_s, -1.0f, 1.0f);
            float thetaOver2 = System.MathF.Acos(s);
            return thetaOver2 * 2.0f;
        }

Here is the caller graph for this function:

GetRotationAxis()

Vec3f SystemEx.Numeric.Quatf.GetRotationAxis

(

)

Computes the normalized rotation axis of this quaternion.

                                        {
            float sinThetaOver2Sq = 1.0f - m_s * m_s;
 
            if ( sinThetaOver2Sq <= 0.0f ) {
                return new  Vec3f(1.0f, 0.0f, 0.0f);
            }
            float   oneOverSinThetaOver2 = 1.0f / System.MathF.Sqrt(sinThetaOver2Sq);
 
            return Vec3f.Normalize(new Vec3f(
                m_v.X * oneOverSinThetaOver2,
                m_v.Y * oneOverSinThetaOver2,
                m_v.Z * oneOverSinThetaOver2
             ));
 
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Invert()

Quatf SystemEx.Numeric.Quatf.Invert ( Quatf q )

static

Computes the inverse of a quaternion.

                                               {
            float temp = Lenght(q);
            Quatf tq = new Quatf(q);
 
            tq.m_s /= temp;
            tq.m_v.X /= -temp;
            tq.m_v.Y /= -temp;
            tq.m_v.Z /= -temp;
            return tq;       // Okay, same norm.
        }

Here is the call graph for this function:

Here is the caller graph for this function:

IsIdentity()

bool SystemEx.Numeric.Quatf.IsIdentity ( Quatf v )

static

Determines whether a quaternion is the identity rotation.

                                                  {
            return v.m_v == Vec3f.Zero && MathF.Abs(v.m_s - 1.0f) <= 0.00001f;
        }

Here is the call graph for this function:

Lenght()

float SystemEx.Numeric.Quatf.Lenght ( Quatf v )

static

Computes the squared length of the quaternion.

                                               {
            return (v.m_s * v.m_s + 
                v.m_v.X * v.m_v.X + 
                v.m_v.Y * v.m_v.Y +
                v.m_v.Z * v.m_v.Z);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

LenghtSqrt()

float SystemEx.Numeric.Quatf.LenghtSqrt ( Quatf v )

static

Computes the Euclidean length of the quaternion.

                                                   {
            return System.MathF.Sqrt(v.m_s * 
                                    v.m_s + v.m_v.X * 
                                    v.m_v.X + v.m_v.Y * 
                                    v.m_v.Y + v.m_v.Z * 
                                    v.m_v.Z);
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Logarithm()

Quatf SystemEx.Numeric.Quatf.Logarithm ( Quatf v )

static

Computes the quaternion logarithm.

                                                  {
 
            Quatf temp = new Quatf( v);
 
            float vLen = Vec3f.LenghtSqrt(temp.m_v);
            float angle = MathF.Atan2(vLen, temp.m_s);
 
            temp.m_s = 0.0f;
 
            if ( vLen > 1e-6f ) {
                float scale = angle / vLen;
                temp.m_v.X *= scale;
                temp.m_v.Y *= scale;
                temp.m_v.Z *= scale;
            } else {
                temp.m_v = Vec3f.Zero;
            }
 
            return temp;
        }

Here is the call graph for this function:

Normalize()

Quatf SystemEx.Numeric.Quatf.Normalize ( Quatf v )

static

Normalizes a quaternion to unit length.

                                                  {
            float norme = LenghtSqrt(v);
            Quatf temp = new Quatf(v);
 
            if ( norme < 1e-12f ) {
                temp.m_s = 1.0f;
                temp.m_v = new Vec3f(0,0,0);
            } else {
                float recip = 1.0f/norme;
 
                temp.m_s *= recip;
                temp.m_v.X *= recip;
                temp.m_v.Y *= recip;
                temp.m_v.Z *= recip;
            }
            return temp;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

operator*() [1/3]

Quatf SystemEx.Numeric.Quatf.operator* ( float a, Quatf b )

static

Multiplicate a float with a quaternion.

                                                          {
            Quatf _ret = new Quatf();
 
            _ret.m_s = a * b.m_s;
            _ret.m_v = a * b.m_v;
 
            return _ret;
        }

Here is the call graph for this function:

operator*() [2/3]

Quatf SystemEx.Numeric.Quatf.operator* ( Quatf a, float b )

static

Multiplicate a quaternion with a float.

                                                            {
            Quatf _ret = new Quatf();
 
            _ret.m_s = a.m_s * b;
            _ret.m_v = a.m_v * b;
 
            return _ret;
        }

Here is the call graph for this function:

operator*() [3/3]

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

static

Multiplies two Quatf component‑wise.

                                                            {
            Quatf qtmp = new Quatf();
 
            float ax = a.m_v.X;
            float ay = a.m_v.Y;
            float az = a.m_v.Z;
 
            float bx = b.m_v.X;
            float by = b.m_v.Y;
            float bz = b.m_v.Z;
 
            float as_ = a.m_s;
            float bs_ = b.m_s;
 
            // Skalarteil
            qtmp.m_s = as_ * bs_ - ax * bx - ay * by - az * bz;
 
            // Vektorteil
            qtmp.m_v = new Vec3f(
                as_ * bx + bs_ * ax + ay * bz - az * by,
                as_ * by + bs_ * ay + az * bx - ax * bz,
                as_ * bz + bs_ * az + ax * by - ay * bx
            );
 
            return qtmp;
        }

Here is the call graph for this function:

operator+()

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

static

Adds two Quatf component‑wise.

                                                            {
            return new Quatf(
                a.m_s + b.m_s,
                a.m_v.X + b.m_v.X,
                a.m_v.Y + b.m_v.Y,
                a.m_v.Z + b.m_v.Z
            );
        }

Here is the call graph for this function:

operator-() [1/2]

Quatf SystemEx.Numeric.Quatf.operator- ( Quatf a )

static

Invert.

                                                   {
            return new Quatf(
                -a.m_s,
                -a.m_v.X,
                -a.m_v.Y,
                -a.m_v.Z
            );
        }

Here is the call graph for this function:

operator-() [2/2]

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

static

Subtracts two Quatf component‑wise.

                                                            {
            return new Quatf(
                a.m_s - b.m_s,
                a.m_v.X - b.m_v.X,
                a.m_v.Y - b.m_v.Y,
                a.m_v.Z - b.m_v.Z
            );
        }

Here is the call graph for this function:

operator/() [1/2]

Quatf SystemEx.Numeric.Quatf.operator/ ( Quatf a, float b )

static

Divides both components of the Quatf by a float.

                                                            {
            Quatf _ret = new Quatf();
 
            _ret.m_s = a.m_s / b;
            _ret.m_v = a.m_v / b;
 
            return _ret;
        }

Here is the call graph for this function:

operator/() [2/2]

Quatf SystemEx.Numeric.Quatf.operator/ ( Quatf a, Quatf b )

static

Divides two Quatf component‑wise.

                                                            {
            return a * Invert(b);
        }

Here is the call graph for this function:

Power()

Quatf SystemEx.Numeric.Quatf.Power ( Quatf v, float Exp )

static

Raises a quaternion to a scalar power.

                                                         {
            if ( System.MathF.Abs(v.m_s) > .9999f ) {
                return v;
            }
 
            // Erhalte halbe angle alpha (alpha = theta/2)
            float   alpha = System.MathF.Acos(v.m_s);
 
            // Berechne neuen alpha Wert
            float   newAlpha = alpha * Exp;
 
            // Berechne neuen s wert
            Quatf result = new Quatf();
            result.m_s = System.MathF.Cos(newAlpha);
 
            // Berechne neue xyz Werte
 
            float   mult = System.MathF.Sin(newAlpha) / System.MathF.Sin(alpha);
            result.m_v.X = v.m_v.X * mult;
            result.m_v.Y = v.m_v.Y * mult;
            result.m_v.Z = v.m_v.Z * mult;
 
            return Normalize(result);
        }

Here is the call graph for this function:

Slerp()

Quatf SystemEx.Numeric.Quatf.Slerp ( Quatf q0, Quatf q1, float t )

static

Performs spherical linear interpolation between two quaternions.

                                                                  { // Spherical linear interpolation. 
            if ( t <= 0.0f ) return q0;
            if ( t >= 1.0f ) return q1;
 
            float cosOmega = DotProduct(q0, q1);
 
            float q1w = q1.m_s;
            float q1x = q1.m_v.X;
            float q1y = q1.m_v.Y;
            float q1z = q1.m_v.Z;
 
            if ( cosOmega < 0.0f ) {
                q1w = -q1w;
                q1x = -q1x;
                q1y = -q1y;
                q1z = -q1z;
                cosOmega = -cosOmega;
            }
 
            Debug.Assert(cosOmega < 1.0f);
 
            // Compute interpolation fraction, checking for quaternions
            // almost exactly the same
 
            float k0, k1;
            if ( cosOmega > 0.9999f ) {
                k0 = 1.0f - t;
                k1 = t;
            } else {
                // Compute the sin of the angle using the
                // trig identity sin^2(omega) + cos^2(omega) = 1
 
                float sinOmega = System.MathF.Sqrt(1.0f - cosOmega*cosOmega);
 
                // Compute the angle from its sin and cosine
 
                float omega = System.MathF.Atan2(sinOmega, cosOmega);
 
                // Compute inverse of denominator, so we only have
                // to divide once
 
                float oneOverSinOmega = 1.0f / sinOmega;
 
                // Compute interpolation parameters
 
                k0 = System.MathF.Sin((1.0f - t) * omega) * oneOverSinOmega;
                k1 = System.MathF.Sin(t * omega) * oneOverSinOmega;
            }
 
            // Interpolate
 
            Quatf result = new Quatf();
 
            result.m_v.X = k0 * q0.m_v.X + k1 * q1x;
            result.m_v.Y = k0 * q0.m_v.Y + k1 * q1y;
            result.m_v.Z = k0 * q0.m_v.Z + k1 * q1z;
            result.m_s = k0 * q0.m_s + k1 * q1w;
 
            // Return it
 
            return result;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

ToAxisAngle()

AxisAngle< Vec3f, float > SystemEx.Numeric.Quatf.ToAxisAngle ( Quatf q )

static

Converts a quaternion into an axis‑angle representation.

                                                                      {
            AxisAngle<Vec3f, float> _ret = new AxisAngle<Vec3f, float>();
 
            _ret.Angle = q.GetRotationAngle();
            _ret.Axis = q.GetRotationAxis();
 
            return _ret;
        }

Here is the call graph for this function:

ToBytes()

FixedVector< byte > SystemEx.Numeric.Quatf.ToBytes

(

)

Converts the vector into a deterministic byte sequence.

This method is used by HashFactory to compute attribute‑driven hashes. The byte layout is stable and platform‑safe, ensuring consistent hashing across devices and backends.

Implements SystemEx.Hash.IHashable< T >.

                                            {
            Cache m = new Cache(sizeof(float) * 4);
 
            for ( byte i = 0 ; i < 4 ; i++ )
                m.WriteRange((ulong)(sizeof(float) * i), Get(i).ToBytes());
 
            return m.ToArrayEx();
        }

Here is the call graph for this function:

Here is the caller graph for this function:

Property Documentation

AxisAngle

AxisAngle<Vec3f, float> SystemEx.Numeric.Quatf.AxisAngle

get

Gets the axis‑angle representation of this quaternion.

CompareMode

CompareType SystemEx.Numeric.Quatf.CompareMode

getset

Gets or sets the comparison mode used by CompareTo(Quatf).

{ get => m_comparebleMode; set => m_comparebleMode = value; }

S

float SystemEx.Numeric.Quatf.S

getset

Gets or sets the scalar component (w) of the quaternion.

{ get => m_s; set => m_s = value; }

V

Vec3f SystemEx.Numeric.Quatf.V

getset

Gets or sets the vector component (x,y,z) of the quaternion.

{ get => m_v; set => m_v = value; }

X

float SystemEx.Numeric.Quatf.X

getset

Gets or sets the X component of the quaternion's vector part.

{ get => m_v.X; set => m_v.X = value; }

Y

float SystemEx.Numeric.Quatf.Y

getset

Gets or sets the Y component of the quaternion's vector part.

{ get => m_v.Y; set => m_v.Y = value; }

Z

float SystemEx.Numeric.Quatf.Z

getset

Gets or sets the Z component of the quaternion's vector part.

{ get => m_v.Z; set => m_v.Z = value; }

---

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

• Quatf.cs